Benchmark: RegEx.test vs. String.includes vs. String.match vs String.matchAll vs String.indexOf

Script Preparation code:

var string = "Hallward glanced round him with a puzzled expression. The room looked as if it had not been lived in for years. A faded Flemish tapestry, a curtained picture, an old Italian cassone, and an almost empty book-case--that was all that it seemed to contain, {{besides}} a chair and a table. As Dorian Gray was lighting a half-burned candle that was standing on the {{mantelshelf}}, he saw that the whole place was covered with dust and that the carpet was in holes. A mouse ran scuffling behind the wainscoting. There was a damp odour of mildew.";
var regex = /{{/g;

Tests:

RegEx.test
regex.test(string);
String.includes
string.includes("{{");
String.match
string.match("{{");
String.matchAll
string.matchAll(regex);
String.indexOf
string.indexOf("{{") > -1;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

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

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/111.0

Browser/OS: Firefox 111 on Windows

View result in a separate tab

Test name	Executions per second
RegEx.test	23592760.0 Ops/sec
String.includes	31776964.0 Ops/sec
String.match	6786172.0 Ops/sec
String.matchAll	13929291.0 Ops/sec
String.indexOf	1652856832.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested.

**Benchmark Definition**

The benchmark is comparing four different methods for searching or extracting patterns from a string in JavaScript:

1. `regex.test(string)`
2. `string.includes("{{")`
3. `string.match("{{")`
4. `string.matchAll(regex)`
5. `string.indexOf("{{")`

These methods are being compared to measure their performance differences.

**Library Used**

None is explicitly mentioned, but it's likely that the `String` object and its methods are used as part of the standard JavaScript library.

**Special JS Features or Syntax**

The benchmark uses a special syntax for regular expressions (`/{{/g)`, which is a global search flag. This flag tells the engine to search for the pattern in the string from the beginning, and if found, continue searching from the end of the match position.

**Benchmark Test Cases**

Each test case measures the execution time (in executions per second) of one of the five methods on a specific string (`string`). The results are:

1. `regex.test(string)`
2. `string.includes("{{")`
3. `string.match("{{")`
4. `string.matchAll(regex)`
5. `string.indexOf("{{")`

**Options Compared**

The benchmark is comparing different approaches to search for patterns in a string:

* **Regex`test()`**: This method uses the regular expression object's `test()` method, which returns a boolean value indicating whether the pattern was found in the string.
* **`includes()`**: This method checks if the specified substring is present in the entire string using the `includes()` method.
* **`match()`**: Similar to `includes()`, but it searches for the first occurrence of the pattern in the string and returns a match array or null if no match is found.
* **`matchAll()`**: This method returns an iterator that yields all matches of the regular expression against the given string, including multiple occurrences.
* **`indexOf()`**: This method returns the index of the first occurrence of the specified value (in this case, `{{`) in the string.

**Pros and Cons**

Here's a brief summary of the pros and cons of each approach:

1. `regex.test()`
	* Pros: Simple to use, fast for simple searches.
	* Cons: May not work correctly for complex patterns or large strings.
2. `includes()`
	* Pros: Fast and easy to use, works well for simple searches.
	* Cons: May be slower than regular expression methods for more complex searches.
3. `match()`
	* Pros: Works well for finding the first occurrence of a pattern, relatively fast.
	* Cons: Can return null if no match is found, may not work correctly for large strings or complex patterns.
4. `matchAll()`
	* Pros: Returns all matches, useful for finding multiple occurrences.
	* Cons: May be slower than other methods due to the overhead of returning an iterator.
5. `indexOf()`
	* Pros: Fast and simple to use, works well for finding a single occurrence.
	* Cons: Only finds the first occurrence, may not work correctly for complex patterns or large strings.

**Other Considerations**

The benchmark assumes that the string is very long, which might impact performance. Also, it's possible that the browser being tested has specific optimizations for certain methods.

**Alternatives**

Some alternatives to these methods include:

* Using a dedicated library like `regex-escapes` for escaping special characters in regular expressions.
* Using a caching mechanism to store and reuse compiled regular expression objects.
* Optimizing string manipulation using techniques like substring replacement or substring concatenation.

Keep in mind that the choice of method depends on the specific requirements of your use case.

Related benchmarks:

RegEx.test vs. String.includes vs. String.match vs String.matchAll vs String.indexOf (version: 0)

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

Created: one year ago by: Guest

Jump to the latest result

RegEx.test

String.includes

String.match

String.matchAll

String.indexOf

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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