Benchmark: JS Regex vs .startsWith vs .indexOf

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; }

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

Autogenerated LLM Summary (model llama3.2:3b, generated 29 days ago):

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

The provided benchmark is designed to compare the performance of different string manipulation methods: Regular Expressions (Regex), `startsWith`, and `indexOf`. The test cases cover various scenarios, including searching for a specific substring at the start or end of a string.

**Benchmark Definition**

The benchmark definition consists of two parts:

1. **Script Preparation Code**: This code sets up the environment for the benchmarks. It defines some global variables:
	* `window.regexStart` and `window.regexEnd`: Regular expression patterns to match at the start and end of strings, respectively.
	* `window.match` and `window.matchLength`: A string to search for and its length, respectively.
	* `window.data`: An array of random strings generated using a custom function.
	* `TOTAL_STRINGS`: The total number of strings in the data array.
2. **Html Preparation Code**: This is an empty HTML snippet that serves as a placeholder for the actual benchmarking code.

**Individual Test Cases**

There are six test cases, each with its own benchmark definition:

1. **Regex Start**: Tests the performance of using a regular expression to search for a pattern at the start of a string.
2. **StartsWith**: Tests the performance of using the `startsWith` method to check if a string starts with a specific substring.
3. **Regex End**: Tests the performance of using a regular expression to search for a pattern at the end of a string.
4. **endsWith**: Tests the performance of using the `endsWith` method to check if a string ends with a specific substring.
5. **StartsWith**: Same as above, but with a different string to search for.
6. **Regex Start**: Same as above, but with an additional layer of complexity.

**Benchmark Results**

The benchmark results show the performance of each test case across multiple executions per second (EPS) on a Chrome 129 browser running on a Mac OS X 10.15.7 system. The results are as follows:

| TestName | ExecutionsPerSecond |
| --- | --- |
| indexOf end | 20028.25390625 |
| indexOf start | 19962.216796875 |
| endsWith | 1907.3641357421875 |
| startsWith | 1848.285888671875 |
| regex start | 871.0967407226562 |
| regex end | 765.4481201171875 |

**Analysis**

The results show that:

* `indexOf` is the fastest method for searching at both the start and end of a string.
* `startsWith` and `endsWith` are slower than `indexOf`, but still relatively fast.
* Regular Expressions (Regex) can be slow compared to the other methods, especially when searching at the start or end of a string.

In general, these results suggest that if you need to perform frequent string searches, using `indexOf` might be a better choice. However, if you need more control over the search pattern, Regular Expressions (Regex) can still be a viable option.

Latest run results:

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

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

Browser/OS: Chrome 125 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
regex start	757.7 Ops/sec
startsWith	1648.0 Ops/sec
regex end	628.3 Ops/sec
endsWith	1382.8 Ops/sec
indexOf start	13883.7 Ops/sec
indexOf end	13826.8 Ops/sec

Related benchmarks:

JS Regex vs .startsWith vs .indexOf (version: 1)

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

Created: 5 years ago by: Registered User

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 29 days ago):