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

Historical Performance Data aggregated from 417 community runs

Desktop Results:

Chrome 294 runs

indexOf start

13K/s

indexOf end

13K/s

startsWith

1K/s

endsWith

1K/s

regex start

616/s

regex end

557/s

Fastest: indexOf start (23.5x faster)

View exact numbers

✓ indexOf start: 13,079 ops/sec
• indexOf end: 12,785 ops/sec
• startsWith: 1,149 ops/sec
• endsWith: 1,142 ops/sec
• regex start: 616 ops/sec
• regex end: 557 ops/sec

Firefox 79 runs

indexOf end

15K/s

indexOf start

15K/s

startsWith

1K/s

endsWith

1K/s

regex start

729/s

regex end

700/s

Fastest: indexOf end (21.9x faster)

View exact numbers

✓ indexOf end: 15,313 ops/sec
• indexOf start: 15,143 ops/sec
• startsWith: 1,218 ops/sec
• endsWith: 1,215 ops/sec
• regex start: 729 ops/sec
• regex end: 700 ops/sec

Safari 13 runs

indexOf start

2K/s

regex start

372/s

startsWith

340/s

indexOf end

252/s

endsWith

249/s

regex end

201/s

Fastest: indexOf start (10.2x faster)

View exact numbers

✓ indexOf start: 2,045 ops/sec
• regex start: 372 ops/sec
• startsWith: 340 ops/sec
• indexOf end: 252 ops/sec
• endsWith: 249 ops/sec
• regex end: 201 ops/sec

Other 6 runs

indexOf start

1K/s

indexOf end

952/s

endsWith

141/s

startsWith

123/s

regex start

110/s

regex end

90/s

Fastest: indexOf start (11.7x faster)

View exact numbers

✓ indexOf start: 1,051 ops/sec
• indexOf end: 952 ops/sec
• endsWith: 141 ops/sec
• startsWith: 123 ops/sec
• regex start: 110 ops/sec
• regex end: 90 ops/sec

Mobile Results:

Chrome 19 runs

indexOf start

5K/s

indexOf end

4K/s

startsWith

820/s

endsWith

816/s

regex start

375/s

regex end

339/s

Fastest: indexOf start (16.2x faster)

View exact numbers

✓ indexOf start: 5,497 ops/sec
• indexOf end: 4,377 ops/sec
• startsWith: 820 ops/sec
• endsWith: 816 ops/sec
• regex start: 375 ops/sec
• regex end: 339 ops/sec

Safari 6 runs

indexOf start

2K/s

regex start

451/s

endsWith

368/s

startsWith

338/s

regex end

290/s

indexOf end

279/s

Fastest: indexOf start (5.9x faster)

View exact numbers

✓ indexOf start: 1,641 ops/sec
• regex start: 451 ops/sec
• endsWith: 368 ops/sec
• startsWith: 338 ops/sec
• regex end: 290 ops/sec
• indexOf end: 279 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

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: one month ago)

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

Browser/OS: Chrome 149 on Windows

View result in a separate tab

indexOf end

8K/s

indexOf start

1K/s

startsWith

969/s

endsWith

947/s

regex start

570/s

regex end

357/s

View exact numbers

Test name	Executions per second
✓ indexOf end	8,269 Ops/sec
indexOf start	1,087 Ops/sec
startsWith	969 Ops/sec
endsWith	947 Ops/sec
regex start	570 Ops/sec
regex end	357 Ops/sec

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.

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.

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: 7 years ago by: Registered User

Go to the latest result

regex start

startsWith

regex end

endsWith

indexOf start

indexOf end

Historical Performance Data aggregated from 417 community runs

Desktop Results:

Chrome 294 runs

Firefox 79 runs

Safari 13 runs

Other 6 runs

Mobile Results:

Chrome 19 runs

Safari 6 runs

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 (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: 7 years ago by: Registered User

Go to the latest result

regex start

startsWith

regex end

endsWith

indexOf start

indexOf end

Historical Performance Data aggregated from 417 community runs

Desktop Results:

Chrome 294 runs

Firefox 79 runs

Safari 13 runs

Other 6 runs

Mobile Results:

Chrome 19 runs

Safari 6 runs

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`