Benchmark: RegEx.test vs. String.includes vs. String.match vs String.startsWith vs ===

Script Preparation code:

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

Tests:

String.includes
string.includes("Hello");
String.match
string.match("Hello");
String.startsWith
string.startsWith("Hello");
String === value
string === "Hello world!"

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
String.includes
String.match
String.startsWith
String === value

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 3 months 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.includes	145317136.0 Ops/sec
String.match	9232000.0 Ops/sec
String.startsWith	75353144.0 Ops/sec
String === value	139048720.0 Ops/sec

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

LLMs can make mistakes. Check important info.

The benchmark provided measures the performance of different string searching methods in JavaScript, specifically for the example string "Hello world!". The individual test cases compare four different approaches to check if the string contains the substring "Hello":

1. **String.includes** - `string.includes("Hello")`
2. **String.match** - `string.match("Hello")`
3. **String.startsWith** - `string.startsWith("Hello")`
4. **Strict Equality Comparison** - `string === "Hello world!"`

### Options Being Compared:

1. **String.includes**:
   - **Purpose**: This method checks if a string contains a specified substring. It returns a boolean value (true or false).
   - **Performance**: This method was found to be the fastest option in the benchmark with `145,317,136` executions per second.
   - **Pros**: Very clear and easy to read; it returns a boolean directly.
   - **Cons**: Not supported in very old browsers (pre-ES6); however, this is largely mitigated by modern browser usage.

2. **String.match**:
   - **Purpose**: This method is designed to retrieve matches of a regular expression. When a string is tested with a simple string (not a regular expression) as the argument, it is treated as a pattern to match against the string.
   - **Performance**: This was the slowest option in the benchmark, with `9,232,000` executions per second.
   - **Pros**: Offers more flexibility through regular expressions for complex matching patterns.
   - **Cons**: Slower in performance for simple substring checks and can introduce more complexity than necessary for straightforward checks.

3. **String.startsWith**:
   - **Purpose**: This method checks if a string begins with a specified substring and returns true or false.
   - **Performance**: It had a moderate performance with `75,353,144` executions per second.
   - **Pros**: Semantic clarity, indicating that the check is specifically about the start of the string; very readable.
   - **Cons**: It only checks the beginning of the string, limiting its utility in some cases.

4. **Strict Equality Comparison**:
   - **Purpose**: This directly checks if the string is exactly equal to another string.
   - **Performance**: It performed similarly to `includes`, with `139,048,720` executions per second, making it the second fastest option.
   - **Pros**: Very fast and simple for exact matches without any fancy method calls.
   - **Cons**: Does not check for partial matches, so it’s not suitable for cases where you only want to check for the presence of a substring.

### Overall Considerations:

- **Readability vs. Performance**: While `String.includes` and strict equality are straightforward and high-performing, methods like `String.match` offer capabilities for more complex scenarios. Developers should choose based on the need: clarity or performance.
- **Browser Support**: While all methods benchmarked are supported in modern browsers, developers should consider client environments when selecting an approach, especially if supporting legacy systems.
- **Complexity and Maintenance**: Overly complex solutions (like using regex with `String.match`) may complicate code maintenance without providing clear benefits in performance or function for simple substring checks.

### Alternatives:

- **Regular Expressions**: If more complex conditions are needed (patterns, case insensitivity, etc.), then crafting a proper regex pattern with `String.match` may be the right route despite its performance drawbacks.
- **Array methods**: For very large strings or datasets, converting the string into an array or using other data structures may benefit certain search algorithms (e.g., binary search), though this increases complexity.
- **Third-party libraries**: Libraries like Lodash or jQuery provide additional utility functions to simplify string manipulation, but using native methods is generally preferred for performance.

In conclusion, this benchmark serves to highlight the various approaches available for checking string contents in JavaScript, weighing standards of performance and usability against the specific requirements of the application.

Related benchmarks:

RegEx.test vs. String.includes vs. String.match vs String.startsWith vs === (version: 1)

Comparing performance of: String.includes vs String.match vs String.startsWith vs String === value

Created: 3 months ago by: Guest

Jump to the latest result

String.includes

String.match

String.startsWith

String === value

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):