Benchmark: JS Regex vs .startsWith vs .indexOf vs. slice equals vs substring

HTML Preparation code:

<div></div>

Script Preparation code:

window.regexStart = /^test/;
window.regexEnd = /test$/;
window.match = 'test';
window.matchLength = window.match.length;
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 start
var x = 0; var TOTAL_STRINGS = window.TOTAL_STRINGS; var data = window.data; var regex = window.regexStart; while (x < TOTAL_STRINGS) { const str = data[x]; regex.test(str); 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; }
regex end
var x = 0; var TOTAL_STRINGS = window.TOTAL_STRINGS; var data = window.data; var regex = window.regexEnd; while (x < TOTAL_STRINGS) { const str = data[x]; regex.test(str); x += 1; }
endsWith
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; }
indexOf start
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; }
indexOf end
var x = 0; var TOTAL_STRINGS = window.TOTAL_STRINGS; var data = window.data; var match = window.match; var length = window.matchLength; while (x < TOTAL_STRINGS) { const str = data[x]; str.indexOf(match) === str.length - length; x += 1; }
slice start equals
var x = 0; var TOTAL_STRINGS = window.TOTAL_STRINGS; var data = window.data; var match = window.match; var length = window.matchLength; while (x < TOTAL_STRINGS) { const str = data[x]; str.slice(0, 4) === match; x += 1; }
substring
var x = 0; var TOTAL_STRINGS = window.TOTAL_STRINGS; var data = window.data; var match = window.match; var length = window.matchLength; while (x < TOTAL_STRINGS) { const str = data[x]; str.substring(0,4) === match; x += 1; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
regex start
startsWith
regex end
endsWith
indexOf start
indexOf end
slice start equals
substring

Fastest: N/A

Slowest: N/A

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/131.0.0.0 Safari/537.36

Browser/OS: Chrome 131 on Windows

View result in a separate tab

indexOf start

5K/s

indexOf end

5K/s

substring

4K/s

startsWith

713/s

endsWith

687/s

slice start equals

423/s

regex start

275/s

regex end

239/s

View exact numbers

Test name	Executions per second
✓ indexOf start	4,628 Ops/sec
indexOf end	4,560 Ops/sec
substring	4,120 Ops/sec
startsWith	713 Ops/sec
endsWith	687 Ops/sec
slice start equals	423 Ops/sec
regex start	275 Ops/sec
regex end	239 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down what is tested in the provided JSON and explain the different options compared.

**Benchmark Test**

The test measures the performance of various string manipulation methods in JavaScript:

1. `Regex`: Using regular expressions to search for a pattern in a string.
2. `Slice` (or `Substring`): Extracting a substring from an original string using slicing or substr extraction.
3. `indexOf`, `endsWith`, and `startsWith`: String method calls that perform different operations on the strings.

**Options Compared**

The test compares the performance of each method for various string lengths, but with only two execution rates (ExecutionsPerSecond) reported for four methods:

1. `slice start equals` (and `substring`) vs. `indexOf`
2. `slice start equals` vs. `endsWith`
3. `slice start equals` vs. `startsWith`

The other methods (`regex`, `indexof end`, and `starts with`) are not compared to each other.

**What's Missing**

- The `slice` method's performance is compared only against `indexOf`. There seems to be an error in the test - it should compare `slice` or `substring` against another string manipulation method, such as `indexOf`.
- The `startsWith` and `endsWith` methods are compared with each other. However, there might be some inconsistencies in execution rates that suggest either a bug or a discrepancy in how these tests were run.

**Performance Insights**

From the benchmark results provided:

* All methods have different performance variations based on browser and device platform.
* In general, for larger strings (e.g., `slice start equals` and `substring`), `indexOf` seems to perform better than other string manipulation methods. However, this can be misleading without considering the actual use case or context of these operations.

The specific reason behind the performance differences across browsers and platforms is not provided here due to a lack of detailed information about how the benchmarking was conducted (e.g., browser versions, device platforms, OS versions, etc.).

JS Regex vs .startsWith vs .indexOf vs. slice equals vs substring (version: 0)

fork of https://www.measurethat.net/Benchmarks/Show/975/11/regex-vs-indexof-vs-startswith-vs-substr

Comparing performance of: `regex start vs startsWith vs regex end vs endsWith vs indexOf start vs indexOf end vs slice start equals vs substring`

Created: 4 years ago by: Guest

Go to the latest result

regex start

startsWith

regex end

endsWith

indexOf start

indexOf end

slice start equals

substring

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

JS Regex vs .startsWith vs .indexOf vs. slice equals vs substring (version: 0)

fork of https://www.measurethat.net/Benchmarks/Show/975/11/regex-vs-indexof-vs-startswith-vs-substr

Comparing performance of: regex start vs startsWith vs regex end vs endsWith vs indexOf start vs indexOf end vs slice start equals vs substring

Created: 4 years ago by: Guest

Go to the latest result

regex start

startsWith

regex end

endsWith

indexOf start

indexOf end

slice start equals

substring

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `regex start vs startsWith vs regex end vs endsWith vs indexOf start vs indexOf end vs slice start equals vs substring`