Benchmark: RegEx.matchAll vs includes no match

Script Preparation code:

var string = "Hello world!";
var regex = /Hello/;

Tests:

String.includesAll
string.includes("{{") && string.includes("}}")
String.matchAll
string.matchAll(new RegExp(`{{((?!}}).+?)}}`, 'g'))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
String.includesAll
String.matchAll

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36

Browser/OS: Chrome 113 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
String.includesAll	14862139.0 Ops/sec
String.matchAll	2894510.5 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

The provided JSON represents two benchmark test cases: `RegEx.matchAll vs includes no match` and two individual test cases, `String.includesAll` and `String.matchAll`.

**Benchmark Definition: RegEx.matchAll vs includes no match**

This benchmark compares the performance of two approaches to check if a string contains a specific substring without any matches. The two approaches are:

1. Using `RegExp.prototype.test()` (not explicitly mentioned in the JSON, but implied by the code) and then checking the result using `includes()` or `indexOf()`, which is equivalent to calling `test()` with an index of 0.
2. Using the `includes()` method.

**Options Compared:**

The benchmark compares the performance of:

1. `String.includes()` (using a substring)
2. `RegExp.prototype.test()` followed by `includes()` or `indexOf()`
3. `Regexp.prototype.test()` followed by `includes()` or `indexOf()` (Note: In modern JavaScript, you can use `RegExp.prototype.test()` with the same syntax as `includes()`)

**Pros and Cons of Each Approach:**

1. **String.includes():**
	* Pros:
		+ Fast and efficient
		+ Works well for most cases
	* Cons:
		+ May be slower than other approaches when dealing with very long strings or complex patterns
		+ Can lead to unnecessary string concatenation and memory allocation if used in a loop
2. **RegExp.prototype.test() followed by includes() or indexOf():**
	* Pros:
		+ More flexible and powerful for complex patterns
	* Cons:
		+ May be slower than `String.includes()` for simple substring searches
		+ Requires more code and may lead to confusion if not used correctly

**Library:**

The `includes()` method is a built-in JavaScript method, which means it's part of the ECMAScript standard.

**Special JS Feature/Syntax:**

There are no special features or syntax used in this benchmark. The code uses standard JavaScript features and conventions.

**Other Considerations:**

When working with regular expressions, consider the following:

* Use `RegExp.prototype.test()` instead of `String.includes()` when dealing with complex patterns that require a match at a specific position.
* Be aware of the overhead of compiling regular expressions using `RegExp` constructors. If you need to perform multiple matches on the same pattern, consider reusing the compiled regular expression.

**Alternatives:**

Other alternatives for substring searching include:

1. `String.indexOf()`: Similar to `includes()`, but returns -1 if no match is found instead of throwing an error.
2. `String.lastIndexOf()`: Similar to `indexOf()`, but searches from the end of the string instead of the beginning.
3. `String.startsWith()` and `String.endsWith()`: Newer JavaScript methods that check for prefix or suffix matches, respectively.

Keep in mind that these alternatives may have different performance characteristics compared to `includes()` and `RegExp.prototype.test()`. Always benchmark your specific use case to determine the most efficient approach.

Related benchmarks:

RegEx.matchAll vs includes no match (version: 0)

Comparing performance of: String.includesAll vs String.matchAll

Created: one year ago by: Guest

Jump to the latest result

String.includesAll

String.matchAll

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):