Benchmark: RegEx.test vs. String.includes vs. String.match vs. IndexOf

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");
String.indexOf
string.indexOf("Hello");

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

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

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

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

**Benchmark Overview**

The benchmark measures the performance of three different ways to search for a substring or regular expression in a string: `string.includes()`, `String.match()`, `regex.test()`, and `indexOf()`.

**Options Compared**

1. **`string.includes(string)`**: This method uses the "includes" algorithm, which is optimized for case-insensitive matching.
2. **`String.match(regexp)`**: This method uses a regular expression engine to search for a pattern in the string. It can be used with or without capturing groups.
3. **`regex.test(string)`**: This method tests if a given string matches a regular expression. It's similar to `String.match()`, but returns a boolean value instead of an array of matches.
4. **`string.indexOf(string)`**: This method uses the "indexOf" algorithm, which is optimized for case-sensitive matching.

**Pros and Cons**

1. **`string.includes()`**:
	* Pros: Fast, efficient, and case-insensitive by default.
	* Cons: May not be as flexible as other options (e.g., can't use regular expressions).
2. **`String.match()`**:
	* Pros: Can be used with regular expressions, supports capturing groups.
	* Cons: May be slower than `string.includes()`, and the overhead of creating a regex engine can slow down performance.
3. **`regex.test()`**:
	* Pros: Similar to `String.match()`, but returns a boolean value instead of an array of matches.
	* Cons: Same as `String.match()`, with the added overhead of testing for match instead of capturing groups.
4. **`string.indexOf()`**:
	* Pros: Fast and efficient, case-sensitive by default.
	* Cons: May not be as flexible as other options (e.g., can't use regular expressions).

**Library/Feature Considerations**

None mentioned in the benchmark definition.

No special JavaScript features or syntax are being tested in this benchmark.

**Alternative Approaches**

Other ways to search for a substring or regular expression in a string include:

* Using `indexOf()` with an offset parameter
* Using a custom implementation using bitwise operations and loop
* Using a library like jQuery's `.grep()` method (not mentioned in the benchmark definition)

Keep in mind that this benchmark is specifically measuring the performance of these four options, so other approaches may not be included for comparison.

Latest run results:

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

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

Browser/OS: Mobile Safari 17 on iOS 17.1.1

View result in a separate tab

Test name	Executions per second
RegEx.test	7039398.5 Ops/sec
String.includes	10107532.0 Ops/sec
String.match	5881327.0 Ops/sec
String.indexOf	15215811.0 Ops/sec

Related benchmarks:

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

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

Created: one year ago by: Guest

Jump to the latest result

RegEx.test

String.includes

String.match

String.indexOf

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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