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

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

Latest run results:

Run details: (Test run date: 10 months 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

Test name	Executions per second
regex start	187.1 Ops/sec
startsWith	391.5 Ops/sec
regex end	170.1 Ops/sec
endsWith	411.7 Ops/sec
indexOf start	2223.2 Ops/sec
indexOf end	2013.9 Ops/sec
includes	1720.6 Ops/sec

Related benchmarks:

JS Regex vs .startsWith vs .indexOf vs includes (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 includes

Created: 10 months ago by: Guest

Jump to the latest result

regex start

startsWith

regex end

endsWith

indexOf start

indexOf end

includes

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