Benchmark: RegEx.test vs. String.includes (end of string matching)

HTML Preparation code:

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

Script Preparation code:

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

Tests:

regex.test
regex.test(string);
string.includes
string.includes("world")

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

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

Browser/OS: Chrome 134 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
regex.test	23823738.0 Ops/sec
string.includes	98594952.0 Ops/sec

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

LLMs can make mistakes. Check important info.

The benchmark provided is designed to compare the performance of two JavaScript methods used for string matching: `RegExp.test()` and `String.includes()`. Both methods are commonly used in JavaScript for checking the presence of a substring or pattern within a string, but they have different implementations and use cases.

### Description of the Comparison

1. **Tests Compared:**
   - `RegExp.test(string)`: This method tests whether a regular expression matches a specified string. In this benchmark, the regular expression `/world/` is used to check for the presence of the substring "world" in the string "Hello world!".
   - `String.includes("world")`: This method checks if a given substring exists within a string. In this case, it checks if the substring "world" is present in "Hello world!".

### Pros and Cons of Each Approach

#### `RegExp.test()`
- **Pros:**
  - **Flexibility**: Regular expressions can express complex patterns, allowing for more sophisticated string matching beyond simple substrings, such as matching multiple variations of a pattern.
  - **Advanced Capabilities**: With regex, you can use anchors, quantifiers, and character classes, making them powerful for text processing tasks.

- **Cons:**
  - **Performance**: Regular expressions can be slower than string methods for simple substring tests, especially in cases of large strings or complex patterns not optimized for performance.
  - **Complexity**: Regular expressions can be hard to read and maintain, especially for developers who may not be familiar with regex syntax.

#### `String.includes()`
- **Pros:**
  - **Simplicity**: The method is straightforward and easy to understand; it simply checks for the presence of a substring without any additional complexity.
  - **Performance**: The benchmark results show that `String.includes()` considerably exceeds the performance of `RegExp.test()` in the executed tests, making it a better choice for simple use cases.

- **Cons:**
  - **Limited Functionality**: This method is only capable of checking for static substrings. It cannot handle more complicated matching scenarios like those possible with regular expressions.

### Benchmark Results

In the provided benchmark results, `String.includes` achieved an impressive execution rate of approximately **98,594,952 executions per second**, whereas `RegExp.test` yielded only about **23,823,738 executions per second**. This significant difference highlights the performance advantage of using `String.includes()` for basic substring checks.

### Other Considerations

- **Context of Use**: The choice between `RegExp.test()` and `String.includes()` should be dictated by the specific needs of the application. If the requirement is merely to check for a substring's existence, `String.includes()` is the superior choice due to its simplicity and efficiency. If pattern matching is required, `RegExp.test()` would be more suitable.
  
- **Alternatives**: Besides using `RegExp.test()` and `String.includes()`, there are other alternatives for string matching in JavaScript:
  - **`String.indexOf()`**: An older method that returns the position of the first occurrence of a specified substring, returning `-1` if not found. While it accomplishes similar tasks, its use is generally discouraged in favor of `String.includes()` for presence checks.
  - **`String.match()`**: Returns an array of matches when a string is tested against a regular expression. Though more comprehensive, it is less efficient than `String.includes()` for simple existence checks.
  - **`String.search()`**: Similar to `RegExp.test()`, this method returns the index of the first match of a regular expression within a string.

In summary, this benchmark effectively demonstrates the performance differences between using regular expressions and simpler string methods, offering guidance for developers on choosing the right tool for string matching based on context and performance requirements.

Related benchmarks:

RegEx.test vs. String.includes (end of string matching) (version: 1)

Comparing performance of: regex.test vs string.includes

Created: 7 days 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 7 days ago):