Benchmark: RegEx.test vs. String.includes vs. String.match (case insensitive)

Script Preparation code:

var string = "Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an Unknown printer took a galley of type and scrambled it to make a type specimen book.";
var regex = /unknown/i;

Tests:

RegEx.test
regex.test(string);
String.includes
string.toLowerCase().includes("unknown");
String.match
string.match(regex);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
RegEx.test
String.includes
String.match

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 26 days ago):

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark JSON and test cases.

**Benchmark Definition**

The benchmark is testing three different approaches to search for a specific string within another string:

1. `RegEx.test`: Using a regular expression (`Regex` object) to test if the specified string exists in the original string.
2. `String.includes`: Using the `includes()` method to check if the specified string is present in the original string.
3. `String.match`: Using the `match()` method with a regular expression (regex) to search for matches.

**Comparison of Options**

Here's a brief overview of each approach:

* **RegEx.test**: This method uses a compiled regex pattern to test if the pattern exists at the beginning of the string. It's efficient but can be slower for large strings or complex patterns.
* **String.includes**: This method checks if the specified string is present in the original string by iterating through the string and checking each character. It's generally faster than `RegEx.test` but might be slower for very large strings due to its linear search nature.
* **String.match**: Similar to `includes()`, this method searches for matches using a regex pattern, but it returns an array of matches if found, which can be useful in certain scenarios.

Pros and Cons:

* **RegEx.test**:
	+ Pros: Efficient for simple patterns, easy to use.
	+ Cons: Can be slower for large strings or complex patterns.
* **String.includes**:
	+ Pros: Generally fast, easy to use.
	+ Cons: Linear search can be slow for very large strings.
* **String.match**:
	+ Pros: Returns array of matches if found, useful in certain scenarios.
	+ Cons: Can be slower than `includes()` due to regex compilation and matching.

**Library Used**

None is explicitly mentioned in the provided benchmark. However, it's worth noting that JavaScript has a built-in `RegExp` object (similar to Python's re module) which provides regular expression matching capabilities.

**Special JS Feature/Syntax**

There doesn't seem to be any special JS feature or syntax being tested in this benchmark.

**Other Alternatives**

Some alternative approaches to these three methods include:

* Using `String.indexOf()` instead of `includes()`, which returns the index of the first occurrence of the specified string.
* Using a library like `regex-approx` for more accurate regex matching, but potentially slower performance.
* Using a different search algorithm or data structure, such as an array or trie, to improve search efficiency.

Keep in mind that these alternatives may not be relevant to this specific benchmark and might require additional context or modifications to the test cases.

Latest run results:

Run details: (Test run date: 2 years ago)

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 15_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.3 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 15 on iOS 15.3.1

View result in a separate tab

Test name	Executions per second
RegEx.test	5121861.5 Ops/sec
String.includes	1852009.9 Ops/sec
String.match	4195292.5 Ops/sec

Related benchmarks:

RegEx.test vs. String.includes vs. String.match (case insensitive) (version: 1)

Comparing performance of: RegEx.test vs String.includes vs String.match (case insensitive)

Comparing performance of: RegEx.test vs String.includes vs String.match

Created: 2 years ago by: Registered User

Jump to the latest result

RegEx.test

String.includes

String.match

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 26 days ago):