Benchmark: String.prototype.includes() vs String.prototype.indexOf() vs RegExp.prototype.test()

HTML Preparation code:

<!--your preparation HTML code goes here-->

Script Preparation code:

var string = '1.7976931348623157e+308'

Tests:

String.prototype.includes()
string.includes('e') || string.includes('E')
String.prototype.indexOf()
string.indexOf('e') !== -1 || string.indexOf('E') !== -1
RegExp.prototype.test()
/[eE]/.test(string)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
String.prototype.includes()
String.prototype.indexOf()
RegExp.prototype.test()

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 8 days ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36

Browser/OS: Chrome 131 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
String.prototype.includes()	79373632.0 Ops/sec
String.prototype.indexOf()	82155056.0 Ops/sec
RegExp.prototype.test()	40416016.0 Ops/sec

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

LLMs can make mistakes. Check important info.

The provided benchmark evaluates three different methods for checking whether a given string contains specific characters ('e' or 'E') in JavaScript. These methods are:

1. **String.prototype.includes()**
2. **String.prototype.indexOf()**
3. **RegExp.prototype.test()**

### Options Compared

- **String.prototype.includes()**:
  - **Benchmark Definition**: `string.includes('e') || string.includes('E')`
  - This method is part of ECMAScript 2015 (ES6) and provides a straightforward way to determine if a substring exists within a string, returning a boolean (true/false).

- **String.prototype.indexOf()**:
  - **Benchmark Definition**: `string.indexOf('e') !== -1 || string.indexOf('E') !== -1`
  - This traditional method returns the first index at which a specified substring can be found within the string, or -1 if it is not present. It effectively checks for the presence of the substring by confirming it does not return -1.

- **RegExp.prototype.test()**:
  - **Benchmark Definition**: `/[eE]/.test(string)`
  - This approach employs Regular Expressions (RegEx) to check if the string contains the characters 'e' or 'E'. The `test` method returns true or false based on the pattern defined.

### Pros and Cons

**String.prototype.includes()**:
- **Pros**:
  - Clear and readable syntax.
  - Directly returns a boolean, which is intuitive for checking existence.
- **Cons**:
  - Slightly less performant in scenarios where multiple checks are required since it is invoked multiple times (once for 'e' and once for 'E').

**String.prototype.indexOf()**:
- **Pros**:
  - Traditional approach, supported in all JavaScript environments.
  - Can be used to find the position of the substring if needed (though not necessary in this benchmark).
- **Cons**:
  - More verbose due to the need for additional comparisons against -1.
  - Less intuitive compared to `includes()` when just checking for presence.

**RegExp.prototype.test()**:
- **Pros**:
  - Flexible and powerful for complex patterns, allowing for more sophisticated string validation.
  - Can be easier to expand for more complex cases with multiple possibilities.
- **Cons**:
  - Slightly more overhead and complexity when used for simple checks, as regex can be overkill for basic substring searches.
  - Can lead to performance issues with complex regex patterns or larger strings.

### Other Considerations

- **Performance**: In the benchmark results, `String.prototype.indexOf()` performed the best with **82,155,056 Executions Per Second**, followed by `String.prototype.includes()` at **79,373,632 Executions Per Second**, and `RegExp.prototype.test()` having the least performance at **40,416,016 Executions Per Second**. This indicates that for cases where simple substring presence checks are needed, `indexOf` and `includes` are more performant than using regular expressions.

- **Readability & Maintainability**: While performance is crucial, code readability and maintainability are also essential. Using `includes()` often provides clearer intent for future developers, making it an excellent option for simpler tasks. In contrasting scenarios where complex pattern matches are necessary, the use of regex would be appropriate despite its complexity.

### Alternatives

1. **Array.prototype.includes()**: If the goal is to check for presence in an array rather than a string, JavaScript also provides the `includes` method for arrays.
  
2. **String.prototype.search()**: This method uses regex to search a string and returns the index of the match, which can also be used to find the presence of patterns.

3. **Debugging Tools**: If performance is critical, consider using profiling tools in the browser’s developer tools to visualize and analyze the performance of different string operations in your specific application context.

In conclusion, the benchmark effectively illustrates important characteristics of different string-searching methods in JavaScript, providing valuable insights into trade-offs between clarity, performance, and complexity.

Related benchmarks:

String.prototype.includes() vs String.prototype.indexOf() vs RegExp.prototype.test() (version: 1)

Comparing performance of: String.prototype.includes() vs String.prototype.indexOf() vs RegExp.prototype.test()

Created: 8 days ago by: Guest

Jump to the latest result

String.prototype.includes()

String.prototype.indexOf()

RegExp.prototype.test()

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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