Benchmark: Regex vs .indexOf vs .startsWith vs .substr 2

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) === 0; 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) === 0; 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

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 the performance of four string comparison methods: Regular Expressions (Regex), `.indexOf()`, `.startsWith()`, and `.substr()` with slicing. The test case creates an array of random strings, each with a length between 1 and 20, and then uses these strings to measure the execution time of each comparison method.

**Options Compared**

1. **Regular Expressions (Regex)**: This option tests the `test()` method of a regular expression object. In this case, the regular expression is `/^test/`, which matches the string "test" at the beginning.
2. **`.indexOf()`**: This option uses the `.indexOf()` method to search for the specified substring within the string.
3. **`.startsWith()`**: This option uses the `.startsWith()` method to check if the string starts with the specified substring.
4. **`.substr()` with slicing**: This option uses the `.substr()` method to extract a subset of characters from the string and then compares it with the specified substring.

**Pros and Cons**

*   **Regex**: Pros: flexible, can match complex patterns, but cons: slow, error-prone, and may not be suitable for all use cases.
*   **.indexOf()**: Pros: efficient, reliable, and widely supported, but cons: may return -1 if the substring is not found, which could lead to unexpected behavior in some cases.
*   **.startsWith()**: Pros: fast, simple, and easy to implement, but cons: may not be suitable for all use cases (e.g., searching for substrings within strings).
*   **.substr() with slicing**: Pros: efficient, flexible, but cons: may lead to unexpected behavior if the substring is longer than the remaining characters in the string.

**Library and Special JavaScript Features**

No specific libraries or special JavaScript features are used in this benchmark, except for the use of regular expressions, which is a standard JavaScript feature.

**Considerations**

When choosing between these options, consider the following factors:

*   Performance: If speed is crucial, `.substr() with slicing` might be a good choice.
*   Flexibility: For complex pattern matching or edge cases, Regex might be necessary.
*   Reliability: `.indexOf()` and `.startsWith()` are generally reliable but may require additional checks in certain scenarios.

**Other Alternatives**

In addition to the four options mentioned, other string comparison methods in JavaScript include:

*   **String.prototype.includes()**: Similar to `.indexOf()`, but returns -1 if the substring is not found.
*   **String.prototype.localeCompare()**: Compares two strings according to their locale and collation order.

Overall, this benchmark provides a useful comparison of four common string comparison methods in JavaScript, allowing users to evaluate which approach best suits their specific use case.

Related benchmarks:

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

Testing some things

Comparing performance of: Regex vs .indexOf vs StartsWith

Created: 7 years ago by: Guest

Jump to the latest result

Regex

.indexOf

StartsWith

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