Benchmark: JS Regex vs .startsWith vs .indexOf vs includes

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; }
includes
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.includes(match) === true; 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
includes

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 years ago)

User agent: Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36

Browser/OS: Chrome Mobile 120 on Android

View result in a separate tab

indexOf start

2K/s

indexOf end

2K/s

includes

2K/s

endsWith

412/s

startsWith

391/s

regex start

187/s

regex end

170/s

View exact numbers

Test name	Executions per second
✓ indexOf start	2,223 Ops/sec
indexOf end	2,014 Ops/sec
includes	1,721 Ops/sec
endsWith	412 Ops/sec
startsWith	391 Ops/sec
regex start	187 Ops/sec
regex end	170 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.

**Benchmark Definition**

The benchmark definition is a JSON object that defines the test scenario. In this case, we have six individual test cases:

1. `regex start`
2. `startsWith`
3. `regex end`
4. `endsWith`
5. `indexOf start`
6. `includes`

These test cases are designed to measure the performance of different string manipulation methods in JavaScript.

**What is being tested?**

The main thing being tested is how fast different methods are to perform a search or check for a substring within a large array of strings. The methods being compared are:

* `regex.test()` (for both `regex start` and `regex end`)
* `str.startsWith()`
* `str.indexOf()`
* `str.includes()`

**Options compared**

For each test case, the following options are being compared:

* `regex test`: This method uses a regular expression to search for a match. In this case, it's looking for a specific pattern (`^.*$`) that is likely used as a simple form of string comparison.
* `startsWith()`: This method checks if a string starts with another string.
* `indexOf()`: This method returns the index of the first occurrence of a substring within a string.
* `includes()`: This method checks if a string includes a substring.

**Why are these methods being compared?**

These methods are being compared to understand their performance characteristics, especially in terms of execution speed and frequency of use. By comparing different methods for similar tasks, we can determine which one is the fastest, most efficient, and therefore likely to be used more often.

**What does this tell us about JavaScript performance?**

This benchmarking exercise provides insight into how JavaScript handles common string manipulation tasks. The results can inform decisions on code optimization, especially when working with large datasets or high-performance applications.

Keep in mind that the results may vary depending on the specific use case, hardware, and software configurations.

JS Regex vs .startsWith vs .indexOf vs includes (version: 0) Benchmark.js

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 includes`

Created: 2 years ago by: Guest

Go to the latest result

regex start

startsWith

regex end

endsWith

indexOf start

indexOf end

includes

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 includes (version: 0) Benchmark.js

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 includes

Created: 2 years ago by: Guest

Go to the latest result

regex start

startsWith

regex end

endsWith

indexOf start

indexOf end

includes

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 includes`