Benchmark: Regex vs .indexOf vs .startsWith

HTML Preparation code:

<div></div>

Script Preparation code:

window.regex = /^test/;
window.match = 'test';
var data = window.data = [];
const possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
var TOTAL_STRINGS = window.TOTAL_STRINGS = 100000;

function getRandomInt(max) {
  return Math.floor(Math.random() * max);
}

function makeRandomString(len) {
  var text = "";
  for( var i=0; i < len; i++ ) {
    text += possible.charAt(getRandomInt(possible.length));
  }
  return text;
}

while (data.length < TOTAL_STRINGS) {
  data.push(makeRandomString(getRandomInt(20)));
}

Tests:

Regex
var x = 0; var TOTAL_STRINGS = window.TOTAL_STRINGS; var data = window.data; var regex = window.regex; while (x < TOTAL_STRINGS) { const str = data[x]; regex.test(str); x += 1; }
.indexOf
var x = 0; var TOTAL_STRINGS = window.TOTAL_STRINGS; var data = window.data; var match = window.match; while (x < TOTAL_STRINGS) { const str = data[x]; str.indexOf(match) !== -1; x += 1; }
.startsWith
var x = 0; var TOTAL_STRINGS = window.TOTAL_STRINGS; var data = window.data; var match = window.match; while (x < TOTAL_STRINGS) { const str = data[x]; str.startsWith(match); x += 1; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Regex
.indexOf
.startsWith

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

The provided JSON represents a JavaScript benchmark test case on the MeasureThat.net website. The test is designed to compare the performance of three string matching methods: regular expressions (.regex), the .indexOf() method, and the .startsWith() method.

**Regular Expressions (.regex)**

In this approach, the `^` character in the regex pattern is used as a prefix match, ensuring that only strings starting with "test" are matched. The test case generates 100,000 random strings of varying lengths, each containing at least one instance of the test string.

**.indexOf() method**

This approach uses the .indexOf() method to search for the test string within each generated string. It does not perform a prefix match and returns the first occurrence of the test string as an index (or -1 if not found).

**.startsWith() method**

Similar to .indexOf(), this approach uses the .startsWith() method to check if the generated strings start with the test string.

Now, let's discuss the pros and cons of each approach:

*   **Regular Expressions (.regex)**:
    *   Pros: Efficient for prefix matches, can handle complex patterns.
    *   Cons: Can be slower due to pattern compilation, may not perform well on large datasets.
*   **.indexOf() method**:
    *   Pros: Fast and efficient for simple substring searches.
    *   Cons: May return the wrong index if the test string is part of a larger string (e.g., "hello world" contains "world"), and it can be slow for very large datasets.
*   **.startsWith() method**:
    *   Pros: Similar to .indexOf(), fast and efficient, but with an additional check for prefix matches.
    *   Cons: May still return incorrect results if the test string is not a prefix of another string (e.g., "hello world").

The performance differences among these approaches are likely due to factors such as:

*   Pattern compilation time (for regular expressions)
*   String search algorithm efficiency
*   Browser or runtime engine optimizations

**Special considerations**

In this benchmark, no special JavaScript features or syntax are used. However, it's worth noting that the use of `window` variables for global scope is a common practice in MeasureThat.net tests.

If you were to modify this test case to include a specific JavaScript feature or syntax, you might consider using:

*   ES6 features like arrow functions, template literals, or classes
*   Modern browser-specific APIs (e.g., WebAssembly)

**Alternatives**

For similar string matching benchmarks, you can explore other libraries or frameworks that provide optimized implementations of these methods. Some examples include:

*   Lodash: A popular utility library with a `some()` function for checking if an element is in an array.
*   underscore.js: Another well-known utility library with various string manipulation functions.

When creating your own benchmark, consider factors like:

*   Dataset size and distribution
*   Browser or runtime engine version
*   Pattern complexity (for regular expressions)
*   Algorithmic efficiency

Latest run results:

Run details: (Test run date: 5 years ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.98 Safari/537.36

Browser/OS: Chrome 71 on Mac OS X 10.14.3

View result in a separate tab

Test name	Executions per second
Regex	463.6 Ops/sec
.indexOf	987.4 Ops/sec
.startsWith	222.5 Ops/sec

Related benchmarks:

Regex vs .indexOf vs .startsWith (version: 0)

Testing some things

Comparing performance of: Regex vs .indexOf vs .startsWith

Created: 5 years ago by: Guest

Jump to the latest result

Regex

.indexOf

.startsWith

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):