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

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/);

Historical Performance Data aggregated from 39 community runs

Desktop Results:

Chrome 33 runs

String.includes

181.8M/s

RegEx.test

52.3M/s

String.match

30.4M/s

Fastest: String.includes (6.0x faster)

View exact numbers

✓ String.includes: 181,753,712 ops/sec
• RegEx.test: 52,324,312 ops/sec
• String.match: 30,442,656 ops/sec

Firefox 6 runs

String.includes

2740.0M/s

RegEx.test

60.4M/s

String.match

33.7M/s

Fastest: String.includes (81.2x faster)

View exact numbers

✓ String.includes: 2,739,950,592 ops/sec
• RegEx.test: 60,426,416 ops/sec
• String.match: 33,724,172 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

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 15 days ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5.2 Safari/605.1.15

Browser/OS: Safari 26 on Mac OS X 10.15.7

View result in a separate tab

String.includes

775.2M/s

RegEx.test

390.1M/s

String.match

141.7M/s

View exact numbers

Test name	Executions per second
✓ String.includes	775,188,352 Ops/sec
RegEx.test	390,073,184 Ops/sec
String.match	141,672,944 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation of what's being tested in this benchmark.

**What is being tested?**

The provided JSON represents a JavaScript microbenchmark that compares three different approaches to search for a substring in a string:

1. `RegEx.test()`
2. `String.includes()`
3. `String.match()`

These functions are used to determine whether a specified pattern exists at the beginning of a string.

**Options compared:**

The benchmark is comparing the performance of these three approaches on a specific test case, where the input string is `"Hello world!"` and the search pattern is `/Hello/`.

Here's what each approach does:

* `RegEx.test()`: Tests whether the entire input string matches the regular expression. In this case, it will return true if the string starts with "Hello".
* `String.includes()`: Returns true if the specified value (in this case, a substring) is present anywhere in the string.
* `String.match()`: Returns an array containing the matched result and the index of the match if the pattern exists at the beginning of the string.

**Pros and Cons:**

Here are some pros and cons for each approach:

* `RegEx.test()`:
	+ Pros: Can be more efficient for simple regular expressions, as it only scans the input string once.
	+ Cons: May not work correctly if the pattern is complex or has multiple groups, which can lead to slower performance.
* `String.includes()`: 
	+ Pros: Simple and easy to use, making it a good choice for quick checks. It's also a built-in method in JavaScript, so it's likely to be optimized by the engine.
	+ Cons: Can be slower than regular expression testing for complex patterns or large strings, as it requires iterating through the entire string.
* `String.match()`: 
	+ Pros: Returns an array of matches, which can be useful in certain situations. It also has a built-in timeout mechanism to prevent excessive processing time.
	+ Cons: May not work correctly if the pattern is empty or doesn't match anything, returning null instead.

**Library and purpose:**

None of these approaches rely on external libraries. However, it's worth noting that `String.includes()` uses the `indexOf()` method internally to find the index of the specified value in the string.

**Special JavaScript feature or syntax:**

There are no special JavaScript features or syntax used in this benchmark. The use of regular expressions and built-in methods like `includes()` and `match()` are standard JavaScript constructs.

**Other alternatives:**

If you needed a more complex search pattern, you might consider using:

* `String.prototype.replace()` with a callback function to replace the matched value
* A dedicated library for string matching or regular expression processing

However, these alternatives would likely incur performance overhead and may not be as straightforward to use as `RegEx.test()`, `String.includes()`, and `String.match()`.

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

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

Created: one year ago by: Guest

Go to the latest result

RegEx.test

String.includes

String.match

Historical Performance Data aggregated from 39 community runs

Desktop Results:

Chrome 33 runs

Firefox 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 db (version: 0)

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

Created: one year ago by: Guest

Go to the latest result

RegEx.test

String.includes

String.match

Historical Performance Data aggregated from 39 community runs

Desktop Results:

Chrome 33 runs

Firefox 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`