Benchmark: RegEx.test vs. String.includes vs. String.match for multiple results version 3

Script Preparation code:

var text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. In leo diam, ornare volutpat nulla eget, porta ullamcorper risus. Ut rutrum quam enim, eget tempus urna molestie et. Pellentesque quis arcu nulla. Duis sed leo scelerisque, semper nisi nec, rhoncus elit. Fusce at ligula id elit semper congue. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Proin sit amet nulla id magna euismod iaculis a id dolor. Vivamus eget neque aliquet, placerat magna id, tincidunt mi. Nulla eu dui ac turpis condimentum congue et at erat. ";
var searchStrings = ['Pellentesque', 'pellentesque', 'PELLENTESQUE'];
var pattern = /pellentesque/i;

Tests:

RegEx.test
pattern.test(text);
String.includes
text.includes(searchStrings[0]) || text.includes(searchStrings[1]);
match
text.match(pattern)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
RegEx.test
String.includes
match

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

The benchmark provided by MeasureThat.net compares three different JavaScript methods for searching a substring within a larger text string: `RegExp.test`, `String.includes`, and `String.match`. Each of these methods has its own characteristics, performance implications, and use cases.

### Comparison of the Options

1. **`RegExp.test`**
   - **Benchmark Definition:** `pattern.test(text);`
   - **Description:** This method uses a regular expression (`pattern`) to test if a match exists in the given text. The regex pattern defined is `/pellentesque/i`, which necessitates case-insensitivity due to the `i` flag.
   - **Pros:**
     - Regular expressions are highly powerful, allowing for more complex patterns, capturing groups, and more advanced matching scenarios beyond simple substring search.
     - Flexibility to change patterns dynamically, supporting complex text processing tasks.
   - **Cons:**
     - Generally slower than simple string searches, as regex engines can involve overhead in compiling and interpreting patterns.
     - Can be less readable and harder to maintain if patterns are very complex.
   - **Use Cases:** Suitable when complex matching rules are required, such as validation, syntax parsing, or when the search criteria involve patterns rather than fixed strings.

2. **`String.includes`**
   - **Benchmark Definition:** `text.includes(searchStrings[0]) || text.includes(searchStrings[1]);`
   - **Description:** This method checks if the text contains a specific substring(s) case-sensitively. Here, it looks for 'Pellentesque', 'pellentesque', and 'PELLENTESQUE'.
   - **Pros:**
     - Simple and intuitive; easy to read and understand.
     - Typically faster than regex due to the lack of compilation and processing complexity.
   - **Cons:**
     - Limited to straightforward substring searches; cannot accommodate patterns or regular expression features.
   - **Use Cases:** Ideal for simple checks like testing the presence of a specific word or phrase in the text.

3. **`String.match`**
   - **Benchmark Definition:** `text.match(pattern);`
   - **Description:** This method retrieves all matches of the regular expression in the input text. The pattern checks for 'pellentesque', treating it as a regex due to the defined variable `pattern`.
   - **Pros:**
     - Allows for capturing multiple instances of a substring if there are more than one occurrences if the global flag (`g`) were used.
     - Offers more functionality to extract matched data compared to `test`.
   - **Cons:**
     - Similar to `RegExp.test`, this approach is generally slower due to regex processing overhead.
     - If not used carefully with proper flags, can lead to unexpected results.
   - **Use Cases:** Useful when you need to extract information from the string or need to know the occurrences of a pattern.

### Performance Results Discussion

From the latest benchmark results, it is evident that:

- **`String.includes`** performed the best with an impressive execution count of **1,408,491,008.0** executions per second, showcasing its efficiency for simple substring searches.
- **`RegExp.test`** followed with **21,394,288.0** executions per second, significantly slower but still usable for scenarios requiring regex.
- **`String.match`** had the lowest performance with **15,167,264.0** executions per second, primarily due to regex overhead.

### Other Considerations

When choosing between these approaches, consider the complexity of your search criteria and the performance needs of your application:

- For simple presence checks of fixed strings, prefer **`String.includes`** for optimal performance and clarity.
- Use **`RegExp.test`** or **`String.match`** if your requirements include pattern matching or additional flexibility with complex text patterns.
  
### Alternatives

As alternatives, consider:

- **`String.indexOf`**: This older method returns the index of the first occurrence of a substring (or -1 if not found) and can be used for similar use cases as `includes`. However, it is case-sensitive and less readable than `includes`.
- **`String.search`**: Similar to `match`, it uses a regex to search and returns the index of the first match, but does not return the matched string itself.

In conclusion, understanding the differences in performance and functionality among these methods allows developers to make informed decisions based on the specific needs of their applications when it comes to string searching in JavaScript.

Latest run results:

Run details: (Test run date: 29 days ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:131.0) Gecko/20100101 Firefox/131.0

Browser/OS: Firefox 131 on Windows

View result in a separate tab

Test name	Executions per second
RegEx.test	21394288.0 Ops/sec
String.includes	1408491008.0 Ops/sec
match	15167264.0 Ops/sec

Related benchmarks:

RegEx.test vs. String.includes vs. String.match for multiple results version 3 (version: 2)

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

Created: 29 days ago by: Registered User

Jump to the latest result

RegEx.test

String.includes

match

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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