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

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

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

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

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

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

**Benchmark Definition**

The benchmark is comparing four different ways to search for a substring in a string:

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

These methods are all used to find the index of the first occurrence of a substring within a larger string.

**Options Compared**

The benchmark is comparing the performance of each method across different browsers and devices. The options being compared include:

* Browser versions: Chrome 110
* Device platforms: Desktop, Windows
* Operating systems: Windows

This allows the benchmark to simulate real-world scenarios and provide more accurate results.

**Pros and Cons**

Here's a brief summary of the pros and cons of each method:

1. **String.includes()**: This method is generally considered fast and efficient, as it uses a simple iterative approach to find the index of the substring. However, it may not be suitable for very large strings or complex patterns.
	* Pros: Fast, easy to use
	* Cons: May not work well with complex patterns or large strings
2. **RegEx.test()**: This method uses regular expressions to search for a pattern in a string. While it provides more flexibility than `String.includes()`, it can be slower and more resource-intensive due to the complexity of regular expression parsing.
	* Pros: Provides more flexibility, suitable for complex patterns
	* Cons: Can be slower and more resource-intensive
3. **String.match()**: This method is similar to `RegEx.test()` but returns an array instead of a boolean value if multiple matches are found. It's generally considered faster than `RegEx.test()` but may require more memory.
	* Pros: Faster than `RegEx.test()`, suitable for multiple matches
	* Cons: May require more memory, less flexible than `String.includes()`
4. **String.search()**: This method is similar to `String.includes()` but returns the index of the first match instead of a boolean value if no match is found.
	* Pros: Similar performance to `String.includes()`, suitable for finding the first occurrence
	* Cons: May not work well with complex patterns or large strings

**Library and Purpose**

The `RegEx` library is used in conjunction with the `test()` method. The purpose of this library is to provide regular expression matching capabilities, which allows developers to search for patterns in strings.

**Special JS Feature/Syntax**

There doesn't appear to be any special JavaScript feature or syntax being tested in this benchmark.

**Other Alternatives**

If you're looking for alternative methods to compare, some options include:

* Using `String.prototype.indexOf()` instead of `String.includes()`
* Using a dedicated string processing library like Apache Commons Lang
* Using a regex engine like PCRE (Perl-Compatible Regular Expressions)

However, it's worth noting that the choices above may not provide the same level of flexibility or performance as the methods being tested in this benchmark.

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

Browser/OS: Chrome 110 on Windows

View result in a separate tab

Test name	Executions per second
RegEx.test	9760300.0 Ops/sec
String.includes	24430248.0 Ops/sec
String.match	5470978.5 Ops/sec
String.search	6106292.0 Ops/sec

Related benchmarks:

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

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

Created: one year ago by: Guest

Jump to the latest result

RegEx.test

String.includes

String.match

String.search

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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