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

Autogenerated LLM Summary (model llama3.2:3b, generated one month 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.).

Latest run results:

Run details: (Test run date: 8 months ago)

User agent: Mozilla/5.0 (X11; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/115.0

Browser/OS: Firefox 115 on Linux

View result in a separate tab

Test name	Executions per second
regex start	1020.6 Ops/sec
startsWith	676.8 Ops/sec
regex end	831.9 Ops/sec
endsWith	676.9 Ops/sec
indexOf start	19190.4 Ops/sec
indexOf end	19044.4 Ops/sec
slice start equals	4615.4 Ops/sec
substring	4575.3 Ops/sec

Related benchmarks:

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: 2 years ago by: Guest

Jump to the latest result

regex start

startsWith

regex end

endsWith

indexOf start

indexOf end

slice start equals

substring

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