Benchmark: RegEx.test vs. String.includes vs. String.match with case insensitivity

Script Preparation code:

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

Tests:

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

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: 12 days ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36

Browser/OS: Chrome 135 on Windows

View result in a separate tab

Test name	Executions per second
RegEx.test	46558752.0 Ops/sec
String.includes	157806928.0 Ops/sec
String.match	6383480.5 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 12 days ago):

LLMs can make mistakes. Check important info.

The benchmark defined in the provided JSON tests the performance of three different approaches to check for the presence of a substring in a string in JavaScript, specifically in a case-insensitive manner. Below are the details of the options compared and their respective pros and cons.

### Benchmarked Approaches

1. **RegEx.test**
   - **Benchmark Definition:** `regex.test(string);`
   - **Test Name:** "RegEx.test"
   - **Pros:**
     - Flexible and powerful for pattern matching beyond simple string presence checks.
     - Supports more complex conditions through regular expressions (e.g., matching multiple patterns, optional characters).
   - **Cons:**
     - May be slower than simple string methods for straightforward substring checks.
     - Initial overhead in creating and compiling a regex may affect performance, especially for small or frequent checks.

2. **String.includes**
   - **Benchmark Definition:** `string.toLowerCase().includes("Hello".toLowerCase());`
   - **Test Name:** "String.includes"
   - **Pros:**
     - Simple and readable syntax for checking substring existence.
     - Performant for straightforward substring search without overhead from regex parsing.
   - **Cons:**
     - Although convenient, this method involves converting both the string and the searched substring to lowercase, which can slow down checks if done frequently on larger strings or repeatedly in loops.

3. **String.match**
   - **Benchmark Definition:** `string.match("Hello");`
   - **Test Name:** "String.match"
   - **Pros:**
     - Similar to RegEx.test, but can return more detailed information, such as the matched string or array of matches.
     - Can be extended to use regexes for more complex pattern matching if needed.
   - **Cons:**
     - When used without regex (just a string), it may not be as efficient as using `includes`, particularly for a simple substring check.
     - This method can also produce complex results (like arrays) that may require additional handling.

### Performance Results

The benchmark results indicate that the `String.includes` method performed the best, with an execution rate of 157,806,928 operations per second. This is likely due to its direct approach for substring searching without the overhead of regex compilation or complex parsing.

The `RegEx.test` method came in second with 46,558,752 executions per second. While it has the disadvantage of regex overhead, it still presents utility for situations requiring more complex string matching.

The `String.match` method was significantly slower at 6,383,480 executions per second. This approach, while capable of returning detailed match information, appears to be less efficient for purely checking substring presence—especially since, in this case, regular expressions were not leveraged.

### Other Considerations

1. **Use Case:** The choice between these methods ultimately depends on the specific needs of the application. If only simple presence checks are required, `String.includes` is often the most appropriate choice. If complex pattern matching is necessary, `RegEx.test` may be the better option, despite the potential performance cost.

2. **Readability and Maintainability:** Developers should also consider maintainability. The readability of `String.includes` makes it an attractive option when working with other developers who may not be familiar with regex.

3. **Alternatives:** In addition to the methods tested, alternatives like string comparison (`string.indexOf('Hello') !== -1`) can also be used for substring presence checks. Similarly, more modern JavaScript frameworks can offer utilities or libraries for string manipulation and searching that may include optimizations beyond native implementations.

By weighing these considerations and understanding the context of each method, developers can choose the most appropriate option based on their performance requirements and use cases.

Related benchmarks:

RegEx.test vs. String.includes vs. String.match with case insensitivity (version: 1)

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

Created: 12 days ago by: Guest

Jump to the latest result

RegEx.test

String.includes

String.match

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 12 days ago):