Benchmark: Search RegExp vs includes vs match

Script Preparation code:

var issues = [{
        name: "Take trash out",
        id: 1,
        state: "open"
    },
    {
        name: "Make a laundry",
        id: 2,
        state: "open"
    },
    {
        name: "Meet a friend in KFC",
        id: 3,
        state: "open"
    }
];
var search = "take";
var regexp = new RegExp(search,'i');

Tests:

RegEx.test
issues.filter(function(issue) {return regexp.test(issue.name)});
String.includes
issues.filter(function(issue) {return issue.name.toLowerCase().includes(search.toLowerCase())});
String.match
issues.filter(function(issue) { return issue.name.toLowerCase().match(search.toLowerCase())});

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
RegEx.test
String.includes
String.match

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

The benchmark provided measures the performance of three different string search methods in JavaScript: regular expressions (`RegExp.test`), `String.includes`, and `String.match`. Each method is applied to a list of issues (string objects) that represent tasks, where the goal is to find matches based on a search term ("take") in the task name.

### Methods Compared

1. **RegExp.test**
   - **Code**: `issues.filter(function(issue) { return regexp.test(issue.name); });`
   - **Description**: This method employs a regular expression to check if the search term exists in the `name` property of each issue. The regular expression `regexp` is constructed to be case-insensitive due to the 'i' flag.
   
2. **String.includes**
   - **Code**: `issues.filter(function(issue) { return issue.name.toLowerCase().includes(search.toLowerCase()); });`
   - **Description**: The `includes` method checks if a given string (search term) is contained within another string (in this case, the `name` of an issue). Both strings are converted to lowercase to perform a case-insensitive comparison.
   
3. **String.match**
   - **Code**: `issues.filter(function(issue) { return issue.name.toLowerCase().match(search.toLowerCase()); });`
   - **Description**: The `match` method is utilized here to find a match for the search term against the issue name as a regular expression. It also uses case-insensitive matching by converting strings to lowercase; however, it doesn't create a new regex for each invocation.

### Performance Results

The benchmark results show the number of times each method can execute per second on a specific Chrome browser environment:

- **`RegExp.test`**: 5,546,115.5 executions/second
- **`String.includes`**: 4,310,142.0 executions/second
- **`String.match`**: 1,982,271.375 executions/second

### Pros and Cons

1. **RegExp.test**
   - **Pros**: 
     - Generally the fastest in this benchmark.
     - Very powerful for complex string matching tasks (e.g., patterns).
   - **Cons**: 
     - May be overkill for simple substring checks.
     - Might introduce complexity if the regex becomes complex.

2. **String.includes**
   - **Pros**: 
     - Simple and intuitive for checking the presence of a substring.
     - Readable syntax, easy to understand for those familiar with standard string operations.
   - **Cons**: 
     - Slightly less performant than RegExp test in this context.
     - Limited to simple substring checks.

3. **String.match**
   - **Pros**: 
     - Suitable for scenarios where you need to extract matching parts or need more than a simple presence check.
     - Can utilize the power of regular expressions.
   - **Cons**: 
     - The performance is notably lower compared to the other two methods.
     - Less efficient for simple existence checks, as it returns all matches instead of just a boolean result.

### Other Considerations

- **Use Cases**: The choice among these methods will depend on the specific use case. If you simply need to check for the presence of a substring, `String.includes` is appropriate, whereas `RegExp.test` is better for more complex patterns or when performance is critical.
- **Browser Compatibility**: All three methods are widely supported in modern browsers, but always check compatibility if targeting older browsers.
- **Complex Regular Expressions**: When you deal with more complex search patterns in `RegExp`, performance can degrade; hence, it’s important to balance complexity and performance.

### Alternatives

In addition to these methods, other alternatives for string searching include:

- **String.indexOf**: This method returns the index of the first occurrence of a specified value in a string. It can also be used for existence checks but is less expressive than `includes`.
  
- **Array.prototype.some**: This method can combine any of the above functionalities and is useful if you want to short-circuit on the first match found, which can improve performance in certain scenarios.
  
- **Third-party Libraries**: Libraries like Lodash or Underscore may offer utility functions that perform string searches that can be optimized for specific tasks.

Overall, understanding the use cases, performance implications, and trade-offs of each method is essential for making informed decisions in JavaScript string manipulation tasks.

Latest run results:

Run details: (Test run date: 24 days 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	5546115.5 Ops/sec
String.includes	4310142.0 Ops/sec
String.match	1982271.4 Ops/sec

Related benchmarks:

Search RegExp vs includes vs match (version: 0)

Comparing performance of: RegEx.test vs String.includes vs String.match

Created: 24 days ago by: Guest

Jump to the latest result

RegEx.test

String.includes

String.match

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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