Benchmark: RegEx.test vs. String.includes vs. String.match vs String.includes (using ||) (with multiple strings)

Script Preparation code:

const string = 'Outstanding';
const regex = /toda|bfi|coms|cot|cos|ipe|ips|rn|rm|ap|sf|st|sp|ss|sv|to|t|o|e|s/;
const searchStrings = ['toda', 'bfi', 'coms', 'cot', 'cos', 'ipe', 'ips', 'rn', 'rm', 'ap', 'sf', 'st', 'sp', 'ss', 'sv', 'to', 't', 'o', 'e', 's'];

Tests:

RegEx.test
/toda|bfi|coms|cot|cos|ipe|ips|rn|rm|ap|sf|st|sp|ss|sv|to|t|o|e|s/.test('Outstanding');
Iteration and String.includes
['toda', 'bfi', 'coms', 'cot', 'cos', 'ipe', 'ips', 'rn', 'rm', 'ap', 'sf', 'st', 'sp', 'ss', 'sv', 'to', 't', 'o', 'e', 's'].some(s => 'Outstanding'.includes(s));
String.match
'Outstanding'.match(/toda|bfi|coms|cot|cos|ipe|ips|rn|rm|ap|sf|st|sp|ss|sv|to|t|o|e|s/);
String.includes (using ||)
'Outstanding'.includes('toda') || 'Outstanding'.includes('bfi') || 'Outstanding'.includes('coms') || 'Outstanding'.includes('cot') || 'Outstanding'.includes('cos') || 'Outstanding'.includes('ipe') || 'Outstanding'.includes('ips') || 'Outstanding'.includes('rn') || 'Outstanding'.includes('rm') || 'Outstanding'.includes('ap') || 'Outstanding'.includes('sf') || 'Outstanding'.includes('st') || 'Outstanding'.includes('sp') || 'Outstanding'.includes('ss') || 'Outstanding'.includes('sv') || 'Outstanding'.includes('to') || 'Outstanding'.includes('t') || 'Outstanding'.includes('o') || 'Outstanding'.includes('e') || 'Outstanding'.includes('s');

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
RegEx.test
Iteration and String.includes
String.match
String.includes (using \|\|)

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 3 months ago)

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

Browser/OS: Chrome 131 on Windows

View result in a separate tab

Test name	Executions per second
RegEx.test	36688956.0 Ops/sec
Iteration and String.includes	6574237.5 Ops/sec
String.match	23977752.0 Ops/sec
String.includes (using \|\|)	6554134.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 3 months ago):

LLMs can make mistakes. Check important info.

This benchmark compares the performance of various string searching methods in JavaScript, specifically focusing on checking if any of a predefined set of substrings exist within a specific string ("Outstanding"). The methods tested are:

1. **RegEx.test**
2. **String.match**
3. **Iteration with String.includes**
4. **Multiple String.includes using logical ORs**

### Benchmarked Methods

1. **RegEx.test**
   - **Implementation**: This method uses a regular expression to determine if the string contains any of the specified patterns. The regex used is `/toda|bfi|coms|cot|cos|ipe|ips|rn|rm|ap|sf|st|sp|ss|sv|to|t|o|e|s/`, which checks for the presence of any of the defined substrings.
   - **Pros**: Regular expressions are powerful and can be concise for complex matching patterns.
   - **Cons**: Regex patterns can be less readable and harder to maintain; they may also introduce performance overhead for more complex expressions.

2. **String.match**
   - **Implementation**: This method is similar to `RegEx.test`, but it returns the actual matches found in the string instead of just a boolean indicating presence. Here, it is used with the same regex.
   - **Pros**: Useful if you need to retrieve the actual matching substrings.
   - **Cons**: It may be slower than `RegEx.test` if you only need a boolean check, as it performs additional work to return matches.

3. **Iteration and String.includes**
   - **Implementation**: This method iterates through an array of search strings with the `some()` function, checking if any of them are included in the target string using `String.includes()`.
   - **Pros**: Readable and straightforward for simple substring checks; can utilize existing string methods which tend to be optimized and efficient.
   - **Cons**: It may be slower than regex for large datasets or more complex patterns, as each check is performed individually.

4. **String.includes (using ||)**
   - **Implementation**: This method performs a series of `String.includes()` checks using logical ORs for each substring.
   - **Pros**: Very clear and direct in intent, which may assist with maintainability and readability.
   - **Cons**: It becomes cumbersome with many substrings, and performance may lag as it doesn’t leverage the efficiency of batch processing found in other methods like regex.

### Performance Results
From the benchmark results:
- `RegEx.test` is the fastest method, executing approximately 36.7 million times per second. 
- `String.match` follows, executing roughly 23.9 million times per second, doing slightly more work.
- The iteration with `String.includes` method executes about 6.6 million times per second, reflecting the overhead of looping through the array.
- The usage of logical ORs with `String.includes` has a similar performance (about 6.5 million executions per second) but is less scalable as the number of substrings increases.

### Other Considerations
**Readability vs Performance**: While performance is critical in many scenarios, readability and maintainability of the code are also very important. Methods leveraging regex can be less clear for developers who are not familiar with regex syntax.

**Alternatives**: Other alternatives could include:
- Using **`Array.prototype.find()`** or **`Array.prototype.filter()`** methods for a more functional programming approach.
- Combining methods or libraries, like using Lodash, which can provide shorthand utilities for views and checks.

Overall, the choice of method should depend on the specific needs of the application, considering factors like performance requirements, the number of substrings to check, and code maintainability preferences.

Related benchmarks:

RegEx.test vs. String.includes vs. String.match vs String.includes (using ||) (with multiple strings) (version: 1)

Comparing performance of: RegEx.test vs Iteration and String.includes vs String.match vs String.includes (using ||)

Created: 3 months ago by: Guest

Jump to the latest result

RegEx.test

Iteration and String.includes

String.match

String.includes (using ||)

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 3 months ago):