Benchmark: .includes() vs .match()

Script Preparation code:

var url='https://www.google.com/matchthis/other/args'

Tests:

text.includes()
url.includes('matchthis') && url.includes('-matchthis')
string.match()
url.match(/(?<!-)matchthis/)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
text.includes()
string.match()

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/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
text.includes()	7642256.5 Ops/sec
string.match()	10483845.0 Ops/sec

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

LLMs can make mistakes. Check important info.

The benchmark defined here aims to compare two different methods for intra-string matching in JavaScript: the `.includes()` method and the `.match()` method. Both of these methods serve the purpose of checking if a specific substring exists within a larger string, but they do so in different ways.

### Benchmark Overview

- **Name**: `.includes() vs .match()`
- **Description**: This benchmark compares two intra-string matching styles.
- **Script Preparation**: A base URL string is defined, which is `"https://www.google.com/matchthis/other/args"`.

### Test Cases Explained

1. **Test Case 1**: `url.includes('matchthis') && url.includes('-matchthis')`
   - **Benchmark Definition**: This test checks if the string `url` contains the substring `'matchthis'` or `'-matchthis'` using the `.includes()` method.
   - **Test Name**: `text.includes()`
   - **Purpose**: The `.includes()` method returns `true` if the specified substring is found within the given string. It is a straightforward and readable method for checking substring presence.

2. **Test Case 2**: `url.match(/(?<!-)matchthis/)`
   - **Benchmark Definition**: This test uses a regular expression to match the substring `'matchthis'`, ensuring it does not follow a hyphen (`-`).
   - **Test Name**: `string.match()`
   - **Purpose**: The `.match()` method retrieves the matches when matching a string against a regular expression. In this specific benchmark, a negative lookbehind (`(?<!-)`) ensures that the substring `'matchthis'` occurs not preceded by a hyphen, adding a layer of complexity to the matching criteria.

### Performance Results

- **Latest Benchmark Results**:
  - **string.match()**: Executed at approximately **10,483,845 executions per second**.
  - **text.includes()**: Executed at approximately **7,642,256.5 executions per second**.

### Comparison of Approaches

#### `.includes()`
- **Pros**:
  - Simpler syntax and more readable (easier for developers to understand at a glance).
  - Faster execution based on benchmark results.
  - No need for regular expressions, which can be more complex and harder to maintain.
  
- **Cons**:
  - Limited functionality for complex matching that may require patterns (for example, finding substrings with certain conditions).
  - Does not support advanced matching features such as lookaheads or lookbehinds.

#### `.match()`
- **Pros**:
  - Powerful for pattern matching using regular expressions.
  - Allows for complex string checks (lookbehinds, quantifiers, etc.) which can facilitate advanced applications.
  
- **Cons**:
  - More complex to understand and write, especially for those unfamiliar with regular expressions.
  - Generally has slower performance for simple substring checks compared to `.includes()`.

### Other Considerations and Alternatives
1. **Alternatives to Consider**:
   - **String.indexOf()**: This method can also be used to check for substring presence. It returns the index of the first occurrence of a specified value, or `-1` if not found, similar to `.includes()`, albeit less readable and requires additional logic to interpret the result.
   - **Regular Expressions**: Besides `.match()`, developers might consider using the `RegExp.test()` method for a true/false result when checking for matches in strings with complex patterns.

2. **Regular Expression Features**: 
   - The use of regular expressions adds significant complexity but is essential for tasks requiring sophisticated matching rules. Developers must weigh the readability and performance of simpler methods against the capabilities of regex.

### Conclusion
In this benchmark, the `.includes()` method outperformed the `.match()` method in terms of execution speed, making it a preferable choice for simple substring searches. However, for conditions requiring intricate matching, the use of `.match()` can be justified despite the potential performance cost. It's crucial for developers to assess their specific application needs when deciding which method to use.

Related benchmarks:

.includes() vs .match() (version: 1)

Compare different intra-string matching styles

Comparing performance of: text.includes() vs string.match()

Created: 7 days ago by: Guest

Jump to the latest result

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