Benchmark: RegEx.test vs. String.includes vs. String.match vs String.search

Script Preparation code:

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

Tests:

RegEx.test
regex.test(string);
String.includes
string.includes("Hello");
String.match
string.match("Hello");
String.search
string.search("Hello")

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

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

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Overview**

The provided benchmark compares four different approaches for searching and matching patterns within strings: `String.includes()`, `String.test()` (with regular expressions), `String.match()`, and `String.search()`. The test cases are designed to measure the performance of each method in different scenarios.

**Options Compared**

1. **`String.includes()`**: This method checks if a specified value exists within a string.
2. **`String.test()` (with regular expressions)**: This method performs a case-sensitive search for a pattern within a string, using the `RegExp.test()` function.
3. **`String.match()`**: This method returns an array of matches if a pattern is found within a string.
4. **`String.search()`**: This method returns the index of the first occurrence of a pattern within a string.

**Pros and Cons**

*   **`String.includes()`**: Pros:
    *   Fastest among the four methods, since it only needs to check if the value exists in the string.
    *   Simple implementation, as it doesn't require complex regular expression logic.
*   Cons:
    *   May be slower for larger strings or complex patterns, as it has to iterate through the entire string.
    *   Not suitable for finding all occurrences of a pattern within a string.

*   **`String.test()` (with regular expressions)**: Pros:
    *   Flexible and powerful, allowing for case-insensitive searches and more complex pattern matching.
*   Cons:
    *   Generally slower than `String.includes()`, as it needs to execute the full regular expression engine.
    *   Requires additional setup and configuration of the regular expression.

*   **`String.match()`**: Pros:
    *   Returns all matches, if any exist.
    *   Can be used for more complex pattern matching.
*   Cons:
    *   May return false positives or empty arrays in certain cases.
    *   Slower than `String.includes()`, due to the additional overhead of searching and compiling regular expressions.

*   **`String.search()`**: Pros:
    + Returns the index of the first occurrence, making it suitable for finding a specific value within a string.
*   Cons:
    - May return `-1` if no match is found, which can be confusing in some cases.
    - Slower than `String.includes()`, due to the additional overhead of searching and compiling regular expressions.

**Library Descriptions**

The benchmark uses two libraries:

1.  **RegExp**: The built-in JavaScript library for working with regular expressions. It provides methods like `test()`, `exec()`, and others for manipulating and executing regular expression patterns.
2.  There is no additional library used in this benchmark, as the focus is on comparing the performance of different string searching methods.

**Special JS Features or Syntax**

There are a few special JavaScript features mentioned in the benchmark:

1.  **Case sensitivity**: The `String.test()` method is case-sensitive, which means it will match the pattern only if the strings exactly match.
2.  **Regular expression syntax**: The `RegExp.test()` function requires careful handling of regular expression patterns to achieve the desired results.

**Other Alternatives**

There are other methods for searching and matching patterns within JavaScript strings that could be considered alternatives in this benchmark:

*   **String.prototype.indexOf()**: This method returns the index of the first occurrence of a specified value within a string.
*   **Array.prototype.includes()**: This method checks if an array includes a specific value.

Related benchmarks:

RegEx.test vs. String.includes vs. String.match vs String.search (version: 0)

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

Created: 3 years ago by: Guest

Jump to the latest result

RegEx.test

String.includes

String.match

String.search

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):