Benchmark: RegEx.test vs. String.includes x twice

Script Preparation code:

var string = "Hello world!";
var regex = /Hel(?:lo|lllo)/;

Tests:

RegEx.test
regex.test(string);
String.includes
string.includes("Hello") || string.includes("Hellllo");

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
RegEx.test
String.includes

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 130 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
RegEx.test	6984919.5 Ops/sec
String.includes	13203424.0 Ops/sec

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

LLMs can make mistakes. Check important info.

The provided benchmark compares two different approaches for checking the presence of a substring within a string in JavaScript: using a regular expression (RegEx) with the `test()` method, and using the `includes()` method of the `String` object.

### Options Compared

1. **RegEx.test**
   - **Benchmark Definition**: `regex.test(string);`
   - **Test Name**: "RegEx.test"
   
   This approach uses a regular expression defined as `/Hel(?:lo|lllo)/`, which attempts to match the string against the pattern. The `test()` method returns `true` if there is a match and `false` otherwise. Regular expressions are powerful tools for pattern matching and can handle complex search criteria with varied inputs easily.

2. **String.includes**
   - **Benchmark Definition**: `string.includes("Hello") || string.includes("Hellllo");`
   - **Test Name**: "String.includes"

This method checks if the string contains the exact substring `"Hello"` or `"Hellllo"`. The `includes()` method is simple and straightforward, returning `true` if the specified substring exists within the string.

### Pros and Cons of Each Approach

**RegEx.test Pros**:
- **Flexibility**: Regular expressions can be tailored to match complex patterns, enabling more sophisticated searches.
- **Single Calls**: Complex patterns can be evaluated in a single call, which can be more efficient than multiple string methods for certain cases.

**RegEx.test Cons**:
- **Performance**: RegEx can be less efficient for simple substring search scenarios, particularly if the pattern is complex and the input string is large. They can lead to higher computational costs.
- **Complexity**: The syntax can be difficult to read and maintain for those unfamiliar with regular expressions.

**String.includes Pros**:
- **Simplicity**: It is easier to understand and use, especially for those without deep knowledge of regexes. 
- **Performance**: For basic substring searches, `includes()` can be faster for straightforward cases since it doesn’t involve parsing and executing a pattern.

**String.includes Cons**:
- **Limited Functionality**: It cannot handle complex pattern matching like regular expressions can. Any variations or patterns need to be checked with separate calls or additional logic.

### Other Considerations

- **Readability**: For maintainable code, simplicity is often preferable, especially when working with team members who may not be fluent in regex syntax.
- **Performance**: Benchmark results indicate a significant difference in execution speed, showing that `String.includes` can execute approximately 1.89 times faster than `RegEx.test` in the tested environment (Chrome 130 on macOS). This could vary by browser or string lengths.
- **Use Cases**: Depending on the context, if you only need to check for exact substring matches without variations, `includes()` would be the go-to option. If you require more advanced pattern matching, RegEx would be more appropriate, at the cost of potential performance.

### Alternatives

1. **String.indexOf**: A traditional approach to check for the presence of a substring, returning the index or `-1` if not found. This method is similar to `includes()`, but may be less readable when checking for presence.
   
2. **String.match()**: This method is used for searching a string with a regular expression but returns the matched results instead of just a boolean, which adds complexity if only existence checking is desired.

3. **Array.prototype.some()**: For cases where you have multiple possible substrings to check and prefer functional programming style, you can convert the substrings into an array and check if any of them are included using the `some()` method.

In summary, the choice between using `RegEx.test` and `String.includes` should be driven by the complexity of the pattern you are trying to match and the necessity for performance in your specific application context.

Related benchmarks:

RegEx.test vs. String.includes x twice (version: 1)

Comparing performance of: RegEx.test vs String.includes

Created: one month ago by: Guest

Jump to the latest result

RegEx.test

String.includes

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