Benchmark: RegEx.test vs. String.includes vs. String.match vs == .slice

Script Preparation code:

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

Tests:

RegEx.test
regex.test(string);
String.includes
string.includes("Hello");
String.match
string.match("Hello");
==
"Hello" == string.slice(0, "Hello".length);
=== known length
string.slice(0, 5) === "Hello"
startsWith
string.startsWith("Hello")

Historical Performance Data aggregated from 6 community runs

Desktop Results:

Chrome 6 runs

=== known length

189.4M/s

String.includes

184.0M/s

181.9M/s

startsWith

92.0M/s

RegEx.test

51.6M/s

String.match

9.7M/s

Fastest: === known length (19.4x faster)

View exact numbers

✓ === known length: 189,410,976 ops/sec
• String.includes: 183,971,360 ops/sec
• ==: 181,894,848 ops/sec
• startsWith: 91,959,544 ops/sec
• RegEx.test: 51,608,328 ops/sec
• String.match: 9,741,514 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
RegEx.test
String.includes
String.match
==
=== known length
startsWith

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) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36 Edg/138.0.0.0

Browser/OS: Chrome 138 on Windows

View result in a separate tab

String.includes

204.5M/s

=== known length

199.5M/s

181.2M/s

startsWith

90.3M/s

RegEx.test

54.5M/s

String.match

11.5M/s

View exact numbers

Test name	Executions per second
✓ String.includes	204,456,704 Ops/sec
=== known length	199,500,192 Ops/sec
==	181,193,424 Ops/sec
startsWith	90,295,720 Ops/sec
RegEx.test	54,454,748 Ops/sec
String.match	11,466,605 Ops/sec

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

LLMs can make mistakes. Check important info.

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

**Benchmark Overview**

The benchmark compares the performance of six different approaches for testing if a string contains or matches a certain pattern:

1. `regex.test(string)`
2. `string.includes("Hello")`
3. `string.match("Hello")`
4. `"Hello" == string.slice(0, "Hello".length)`
5. `string.slice(0, 5) === "Hello"`
6. `string.startsWith("Hello")`

**Options Compared**

Each option is compared to measure its performance:

* `regex.test(string)` uses a regular expression engine to test if the string contains the pattern.
* `string.includes("Hello")` uses a simple substring search with the `includes()` method.
* `string.match("Hello")` also uses a regular expression engine, but it's less efficient than `regex.test()`.
* `"Hello" == string.slice(0, "Hello".length)` compares the sliced string with a hardcoded string using the loose equality operator (`==`).
* `string.slice(0, 5) === "Hello"` compares the sliced string with a hardcoded string using the strict equality operator (`===`).
* `string.startsWith("Hello")` uses a simple check for the starting index of the pattern.

**Pros and Cons**

Here's a brief summary of each option:

1. **regex.test(string)**:
	* Pros: efficient, flexible, and powerful.
	* Cons: may be slower due to the overhead of the regular expression engine.
2. **string.includes("Hello")**:
	* Pros: simple, fast, and widely supported.
	* Cons: less accurate than `regex.test()` or `string.match()`, as it only checks for substring presence, not exact matches.
3. **string.match("Hello")**:
	* Pros: similar to `regex.test()`, but less efficient due to the specific syntax.
	* Cons: may produce incorrect results if the pattern is complex.
4. **"Hello" == string.slice(0, "Hello".length)**:
	* Pros: simple and fast for simple cases.
	* Cons: inefficient for larger strings or more complex patterns, as it creates a new slice object.
5. **string.slice(0, 5) === "Hello"`:
	* Pros: similar to the previous option, but uses strict equality (`===`).
	* Cons: less accurate than `regex.test()` or `string.match()`, and may be slower due to the overhead of the comparison.
6. **string.startsWith("Hello")**:
	* Pros: simple and fast for simple cases.
	* Cons: less flexible than other options, as it only checks for the starting index.

**Libraries and Special Features**

None of these options require a specific library or special feature in JavaScript.

However, if you're interested in exploring alternative approaches, you can consider using:

* `RegExp` objects with the `test()` method
* `String.prototype.includes()` and `String.prototype.match()`
* `String.prototype.startsWith()` (available in modern browsers)
* Custom implementations using bitwise operations or other techniques

Keep in mind that these alternatives may not be as efficient or accurate as the original options.

**Benchmark Results**

The benchmark results show that:

1. `string.startsWith("Hello")` is the fastest option, followed closely by `regex.test(string)` and `string.includes("Hello")`.
2. The order of performance varies across browsers and devices, highlighting the importance of testing multiple scenarios.

I hope this explanation helps you understand the benchmark and its results!

RegEx.test vs. String.includes vs. String.match vs == .slice (version: 2)

Comparing performance of: `RegEx.test vs String.includes vs String.match vs == vs === known length vs startsWith`

Created: 3 years ago by: Registered User

Go to the latest result

RegEx.test

String.includes

String.match

==

=== known length

startsWith

Historical Performance Data aggregated from 6 community runs

Desktop Results:

Chrome 6 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

RegEx.test vs. String.includes vs. String.match vs == .slice (version: 2)

Comparing performance of: RegEx.test vs String.includes vs String.match vs == vs === known length vs startsWith

Created: 3 years ago by: Registered User

Go to the latest result

RegEx.test

String.includes

String.match

==

=== known length

startsWith

Historical Performance Data aggregated from 6 community runs

Desktop Results:

Chrome 6 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `RegEx.test vs String.includes vs String.match vs == vs === known length vs startsWith`