Benchmark: Find substring in a long string

Script Preparation code:

var string = 'test:segment:foo-bar:EBAC7R$MTVEQV3$GWF2WF2-2025@20240902:lorem-ipsum:v1:85136c79cbf9fe36bb9d05d0639c70c265c18d37'

Tests:

IndexOf
string.indexOf(':foo-bar:')
Includes
string.includes(':foo-bar:')
test (regex)
pattern = /:foo-bar:/ pattern.test(string)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
IndexOf
Includes
test (regex)

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one month ago)

User agent: Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Mobile Safari/537.36

Browser/OS: Chrome Mobile 130 on Android

View result in a separate tab

Test name	Executions per second
IndexOf	11195393.0 Ops/sec
Includes	10874977.0 Ops/sec
test (regex)	2952427.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):

LLMs can make mistakes. Check important info.

This benchmark focuses on evaluating the performance of different string search methods in JavaScript when attempting to find a substring (in this case, the string `':foo-bar:'`) within a longer string. The benchmark utilizes three distinct approaches: `indexOf`, `includes`, and regular expressions for testing (`regex`).

### Test Cases and Approaches

1. **IndexOf**:
   - **Benchmark Definition**: `string.indexOf(':foo-bar:')`
   - **Description**: The `indexOf` method returns the index of the first occurrence of a specified substring within the calling string. If the substring isn't found, it returns -1.
   - **Pros**: 
     - Older and well-supported method across all JavaScript environments.
     - Straightforward and easy to use.
   - **Cons**:
     - Requires additional checks (e.g., checking if the result is -1) to determine if the substring exists.
     - May be less expressive than newer methods.

2. **Includes**:
   - **Benchmark Definition**: `string.includes(':foo-bar:')`
   - **Description**: The `includes` method checks if the substring appears in the string and returns a boolean (`true` or `false`).
   - **Pros**: 
     - More readable and intention-revealing than `indexOf`, as it directly answers whether the substring exists.
     - Simpler syntax and no need for index checks.
   - **Cons**: 
     - May not be available in older JavaScript environments, although it has broad support in recent browsers.

3. **Test (Regex)**:
   - **Benchmark Definition**: `pattern = /:foo-bar:/\r\npattern.test(string)`
   - **Description**: This approach utilizes a regular expression to test for the presence of the substring. The `test` method of a regular expression object returns a boolean indicating whether there was a match.
   - **Pros**: 
     - Powerful and flexible for more complex patterns beyond simple substring searching.
     - Can handle more intricate matching scenarios (e.g., using wildcards or anchors).
   - **Cons**:
     - Performance may be lower for simple substring checks due to the overhead of compiling the regex.
     - More complex syntax compared to `indexOf` and `includes`, which may lead to readability concerns in simpler cases.

### Benchmark Results

The benchmark results reveal the execution speed (in executions per second) for each method on a specific Firefox version:

- **IndexOf**: 2,211,938,048 executions per second
- **Includes**: 2,114,672,384 executions per second
- **test (regex)**: 36,263,584 executions per second

From these results, it's clear that both `indexOf` and `includes` are significantly faster than the regex-based approach. When sheer performance is a priority, especially for simple substring searches, either `indexOf` or `includes` would be preferable. The differences in performance might guide a decision in selecting one over the other, with the added benefit of readability favoring `includes`.

### Alternatives

While the benchmark focuses on string searching through these three methods, there are alternative approaches to consider:

- **Split Method**: You could also split the string by a delimiter and check for the existence of the substring in the resulting array. Although it may be less efficient, it could be simpler in some contexts where you need to extract multiple parts from the string.
  
- **Looping**: For extremely specific or custom needs, a manual search using loops (for example, iterating through characters) could be implemented, but it would generally be less efficient and less readable than the aforementioned methods.

In conclusion, selecting the appropriate method for substring searching in JavaScript largely depends on the performance needs, readability preferences, and potential complexity of the search patterns required in your application. For common cases of substring checks, `includes` often provides the best balance between performance and clarity.

Related benchmarks:

Find substring in a long string (version: 2)

Benchmark finding a string in a substring via several methods.

Comparing performance of: IndexOf vs Includes vs test (regex)

Created: one month ago by: Registered User

Jump to the latest result

IndexOf

Includes

test (regex)

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):