Benchmark: JS Regex vs .startsWith vs .indexOf and lastIndexOf

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.lastIndexOf(match) === str.length - length; 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

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 132 on Windows

View result in a separate tab

Test name	Executions per second
regex start	394.9 Ops/sec
startsWith	967.6 Ops/sec
regex end	348.8 Ops/sec
endsWith	968.3 Ops/sec
indexOf start	10258.3 Ops/sec
indexOf end	252.3 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what's being tested.

**Benchmark Overview**

The benchmark compares the performance of four string manipulation functions in JavaScript:

1. `regexStart` (a regular expression that checks if a string starts with "test")
2. `startsWith` (a method that checks if a string starts with a given value)
3. `endsWith` (a method that checks if a string ends with a given value)
4. `indexOfStart` (a method that searches for the index of a substring starting at a specific position)

**Comparison**

The benchmark prepares two arrays of random strings (`data`) and a regular expression object (`regexStart`) to test `regexStart`. The other three tests use predefined values for comparison.

The tests are designed to compare the number of executions per second (ExecutionsPerSecond) for each function. The test with the highest value is considered the fastest.

**Pros and Cons**

1. **`regexStart`**:
	* Pros: uses regular expressions, which can be powerful for pattern matching.
	* Cons: slow due to the overhead of compiling a regular expression, and may not perform well on non-regular expression strings.
2. **`startsWith`**:
	* Pros: simple and efficient method that uses a simple string comparison.
	* Cons: slower than `regexStart` for longer strings or more complex patterns.
3. **`endsWith`**:
	* Pros: similar to `startsWith`, but with the opposite logic.
	* Cons: same limitations as `startsWith`.
4. **`indexOfStart`**:
	* Pros: uses a simple substring search, which can be efficient for shorter strings.
	* Cons: slower than `regexStart` and `startsWith` for longer strings or more complex patterns.

**Other Considerations**

* The benchmark does not test the use of `lastIndexOf`, which is similar to `indexOfStart`, but searches from the end of the string instead of the start.
* The use of Chrome as the browser may introduce platform-specific optimizations that affect the results.

Overall, this benchmark provides a good starting point for comparing the performance of different string manipulation functions in JavaScript. However, the results should be interpreted with caution, considering the specific use case and platform being tested.

Related benchmarks:

JS Regex vs .startsWith vs .indexOf and lastIndexOf (version: 0)

fork of https://www.measurethat.net/Benchmarks/Show/975/11/regex-vs-indexof-vs-startswith-vs-substr "aaa".IndexOf("a") will fail for ends with

Comparing performance of: regex start vs startsWith vs regex end vs endsWith vs indexOf start vs indexOf end

Created: 2 years ago by: Guest

Jump to the latest result

regex start

startsWith

regex end

endsWith

indexOf start

indexOf end

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):