Benchmark: RegEx.test vs. String.includes vs. String.match vs String.match(regex)

Script Preparation code:

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

Tests:

RegEx.test
regex.test(string);
String.includes
string.includes("Hello");
String.match
string.match("Hello");
String.match with regex
string.match(regex);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
RegEx.test
String.includes
String.match
String.match with regex

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/109.0.0.0 Safari/537.36

Browser/OS: Chrome 109 on Windows

View result in a separate tab

Test name	Executions per second
RegEx.test	12527297.0 Ops/sec
String.includes	30034456.0 Ops/sec
String.match	7332567.5 Ops/sec
String.match with regex	8451095.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Measuring the performance of different approaches to regular expression matching in JavaScript is an interesting benchmark.

**What's being tested:**

The provided JSON represents a benchmark that compares four approaches for matching regular expressions (RegEx) against strings:

1. `String.includes()`: A method to check if a substring exists within a string.
2. `String.match()`: A method to search for the first occurrence of a pattern in a string and returns an array of matches or null if no match is found.
3. `String.match(regex)`: A method that uses a regular expression object as its second argument, which allows for more advanced matching capabilities.

The benchmark measures the number of executions per second (ExecutionsPerSecond) for each approach using Chrome 109 on Windows desktop devices.

**Options compared:**

* `String.includes()`
* `String.match()`
* `String.match(regex)` with a regular expression object
	+ Pros:
		- Can be more efficient than other approaches when only searching for exact matches.
		- Allows for global matching (i.e., `g` flag) for finding all occurrences of the pattern in the string.
	+ Cons:
		- May not be as flexible as `String.match(regex)` due to limitations on flags and modifiers.

**Pros and cons:**

* **String.includes():**
	+ Pros:
		- Simple, straightforward approach with good performance.
		- No need to specify flags or modifiers.
	+ Cons:
		- Can be slower than other approaches for large strings or complex patterns.
		- Not suitable for global matching or specific character classes.

* **String.match():**
	+ Pros:
		- Supports both exact and approximate matches (i.e., `g` flag).
		- Allows for specifying flags and modifiers, making it more flexible.
	+ Cons:
		- Can be slower than `String.includes()` due to the overhead of parsing the regular expression.

* **String.match(regex):**
	+ Pros:
		- Most flexible approach, allowing for any combination of flags, modifiers, and character classes.
		- Supports global matching (i.e., `g` flag) out-of-the-box.
	+ Cons:
		- May be slower due to the overhead of compiling the regular expression.

**Library usage:**

The benchmark uses native JavaScript methods (`String.includes()`, `String.match()`), so no libraries are involved in this comparison.

No special JavaScript features or syntax are required for these approaches, making them accessible to a wide range of developers.

**Alternatives:**

If you want to explore other approaches, consider:

* Using third-party regular expression engines like RegEx.js or regex-js.
* Implementing your own regular expression parser and engine using native JavaScript.
* Investigating alternative string matching algorithms like Knuth-Morris-Pratt (KMP) or Rabin-Karp.

Keep in mind that these alternatives may have different trade-offs in terms of performance, complexity, and flexibility.

Related benchmarks:

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

Comparing performance of: RegEx.test vs String.includes vs String.match vs String.match with regex

Created: one year ago by: Guest

Jump to the latest result

RegEx.test

String.includes

String.match

String.match with regex

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