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

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 1,125 community runs

Desktop Results:

Chrome 885 runs

String.includes

29.4M/s

RegEx.test

12.1M/s

String.match

6.7M/s

Fastest: String.includes (4.4x faster)

View exact numbers

✓ String.includes: 29,395,834 ops/sec
• RegEx.test: 12,144,667 ops/sec
• String.match: 6,714,975 ops/sec

Firefox 146 runs

String.includes

1452.7M/s

RegEx.test

40.7M/s

String.match

19.7M/s

Fastest: String.includes (73.8x faster)

View exact numbers

✓ String.includes: 1,452,672,256 ops/sec
• RegEx.test: 40,666,824 ops/sec
• String.match: 19,678,120 ops/sec

Safari 32 runs

RegEx.test

54.8M/s

String.includes

28.6M/s

String.match

14.9M/s

Fastest: RegEx.test (3.7x faster)

View exact numbers

✓ RegEx.test: 54,787,940 ops/sec
• String.includes: 28,643,542 ops/sec
• String.match: 14,946,438 ops/sec

Other 15 runs

String.includes

27.9M/s

RegEx.test

11.5M/s

String.match

7.0M/s

Fastest: String.includes (4.0x faster)

View exact numbers

✓ String.includes: 27,900,214 ops/sec
• RegEx.test: 11,541,375 ops/sec
• String.match: 7,012,830 ops/sec

Mobile Results:

Chrome 33 runs

String.includes

13.2M/s

RegEx.test

5.3M/s

String.match

3.0M/s

Fastest: String.includes (4.4x faster)

View exact numbers

✓ String.includes: 13,243,883 ops/sec
• RegEx.test: 5,282,012 ops/sec
• String.match: 3,042,863 ops/sec

Safari 14 runs

String.includes

21.1M/s

RegEx.test

16.9M/s

String.match

11.5M/s

Fastest: String.includes (1.8x faster)

View exact numbers

✓ String.includes: 21,065,230 ops/sec
• RegEx.test: 16,911,086 ops/sec
• String.match: 11,531,308 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: 13 days ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:153.0) Gecko/20100101 Firefox/153.0

Browser/OS: Firefox 153 on Windows

View result in a separate tab

String.includes

1653.0M/s

RegEx.test

40.7M/s

String.match

21.6M/s

View exact numbers

Test name	Executions per second
✓ String.includes	1,652,979,328 Ops/sec
RegEx.test	40,678,084 Ops/sec
String.match	21,606,092 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 provided JSON data to understand what's being tested and compare different approaches.

**Benchmark Definition**

The benchmark is testing three approaches for searching a specific substring in a string:

1. `RegEx.test()`: This approach uses regular expressions (regex) to search for the substring.
2. `String.includes()`: This approach uses the `includes()` method of the String object, which checks if a certain value exists within the string.
3. `String.match()`: This approach uses the `match()` method of the String object, which searches for a pattern in the string and returns an array of matches.

**Options Compared**

The benchmark is comparing these three approaches to measure their performance difference.

**Pros and Cons of Each Approach**

1. **RegEx.test()**:
	* Pros: Can be very efficient if used correctly, as it uses a specialized engine optimized for regex matching.
	* Cons: Can be slower due to the overhead of the regex engine, especially for complex patterns. Also, can be vulnerable to performance issues if not properly configured or maintained.
2. **String.includes()**:
	* Pros: Fast and lightweight, as it's implemented in native code. It's also relatively simple to use and doesn't require any setup or configuration.
	* Cons: May not perform well with large strings or complex searches, as it uses a naive approach that may involve iterating over the entire string.
3. **String.match()**:
	* Pros: Similar to `includes()`, but offers more flexibility in terms of pattern matching and can be faster for certain use cases. However, it's also relatively lightweight and easy to use.
	* Cons: May have slightly higher overhead than `includes()` due to the additional complexity of pattern matching.

**Library/Functionality Used**

None of these functions rely on external libraries. They are all part of the built-in JavaScript API.

**Special JS Feature/Syntax**

There is no special JavaScript feature or syntax being used in this benchmark. It's purely functional programming, with a focus on comparing different approaches for substring searching.

**Other Alternatives**

If you're interested in exploring alternative approaches to substring searching, here are some options:

1. **Using a dedicated regex library**: For more complex or optimized regex patterns, using a dedicated library like `regex-escape` or `regex-test` might be beneficial.
2. **Using a custom implementation**: Depending on your specific use case and requirements, you might consider implementing your own substring searching algorithm from scratch.
3. **Using other built-in methods**: Besides `includes()` and `match()`, you could also explore using other built-in methods like `indexOf()` or `lastIndexOf()` for substring searching.

Keep in mind that the performance differences between these approaches can be significant, especially for large strings or complex searches. The benchmark data provides valuable insights into which approach is most efficient under different conditions.

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

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

Created: 5 years ago by: Guest

Go to the latest result

RegEx.test

String.includes

String.match

Historical Performance Data aggregated from 1,125 community runs

Desktop Results:

Chrome 885 runs

Firefox 146 runs

Safari 32 runs

Other 15 runs

Mobile Results:

Chrome 33 runs

Safari 14 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 (version: 0)

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

Created: 5 years ago by: Guest

Go to the latest result

RegEx.test

String.includes

String.match

Historical Performance Data aggregated from 1,125 community runs

Desktop Results:

Chrome 885 runs

Firefox 146 runs

Safari 32 runs

Other 15 runs

Mobile Results:

Chrome 33 runs

Safari 14 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`