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

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: 3 months ago)

User agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:129.0) Gecko/20100101 Firefox/129.0

Browser/OS: Firefox 129 on Ubuntu

View result in a separate tab

Test name	Executions per second
RegEx.test	36107548.0 Ops/sec
String.includes	1767422720.0 Ops/sec
String.match	13541992.0 Ops/sec
==	1766788480.0 Ops/sec
=== known length	1756921216.0 Ops/sec
startsWith	1856660224.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 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!

Related benchmarks:

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: one year ago by: Registered User

Jump to the latest result

RegEx.test

String.includes

String.match

==

=== known length

startsWith

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