Benchmark: RegEx.test vs. String.includes vs. String.match vs String.indexOf 65444

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.indexOf
string.indexOf("Hello") > -1

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

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

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the benchmark.

The provided JSON represents a microbenchmark that tests the performance of three string comparison methods: `RegEx.test()`, `String.includes()`, and `String.match()`. The benchmark is designed to measure which method is the fastest for searching a specific pattern within a given string.

Here are the options being compared:

1. **`RegEx.test()`**: This method tests whether a regular expression matches at the beginning of the string.
2. **`String.includes()`**: This method checks if a substring (in this case, "Hello") is present anywhere in the original string ("Hello world!").
3. **`String.match()`**: This method returns an array containing the first match or `null` if no match is found.
4. **`String.indexOf()`**: This method returns the index of the first occurrence of the specified substring (in this case, "Hello") in the original string.

Let's discuss the pros and cons of each approach:

*   **`RegEx.test()`**:
    *   Pros: Efficient for matching at the beginning of a string. Can be faster due to early returns.
    *   Cons: May not be suitable for more complex searches or when the pattern is not at the start of the string.
*   **`String.includes()`**:
    *   Pros: Easy to use, widely supported. Fast in most cases since it avoids explicit loop iteration.
    *   Cons: Can lead to slower performance if the substring is large and the search space is extensive, due to its linear scan nature.
*   **`String.match()`**:
    *   Pros: Flexibility for capturing groups or handling multiple patterns at once. Useful in cases where you want more control over the matching process.
    *   Cons: Returns `null` if no match is found, which might be slower than other methods that return a direct boolean result (e.g., `String.indexOf()`).
*   **`String.indexOf()`**:
    *   Pros: Simple to use. Offers early returns and can be faster in most cases since it stops scanning as soon as the first match is found.
    *   Cons: May lead to slower performance if the substring is very large or not present at all, due to its linear scan nature.

For this benchmark, `String.indexOf()` appears to be the fastest method for finding a specific string within another string. However, it's essential to consider your use case and potential edge cases before choosing a string comparison method.

In terms of the actual JavaScript libraries being used in these benchmarks:

*   None are explicitly mentioned as being used.
*   No special JS features or syntax is utilized beyond standard JavaScript syntax for creating regular expressions (`/Hello/)`, strings, and conditional statements (e.g., `if (string.indexOf("Hello") > -1)`).

For alternatives to microbenchmarks like this one:

*   **Benchmarks with multiple browsers:** Using a tool like BrowserStack or Sauce Labs can help ensure the results are representative of different browsers and versions.
*   **Benchmarking frameworks like BenchmarkJS, Fast.js, or Microbenchmark:** These tools provide more extensive benchmarking features and support for more test cases than what's shown here.

Keep in mind that microbenchmarks like this one are typically small-scale tests intended to demonstrate performance differences between specific methods. For production-level applications, you may need to consider a broader set of factors when choosing an algorithm or implementation.

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36 Edg/119.0.0.0

Browser/OS: Chrome 119 on Windows

View result in a separate tab

Test name	Executions per second
RegEx.test	8238987.5 Ops/sec
String.includes	19412538.0 Ops/sec
String.match	4749943.5 Ops/sec
string.indexOf	19771820.0 Ops/sec

Related benchmarks:

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

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

Created: one year ago by: Guest

Jump to the latest result

RegEx.test

String.includes

String.match

string.indexOf

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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