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

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:131.0) Gecko/20100101 Firefox/131.0

Browser/OS: Firefox 131 on Windows

View result in a separate tab

startsWith

5K/s

includes

4K/s

indexOf end

3K/s

endsWith

3K/s

indexOf start

2K/s

regex end

194/s

regex start

185/s

View exact numbers

Test name	Executions per second
✓ startsWith	4,668 Ops/sec
includes	3,693 Ops/sec
indexOf end	2,887 Ops/sec
endsWith	2,837 Ops/sec
indexOf start	1,760 Ops/sec
regex end	194 Ops/sec
regex start	185 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 regex benchmarks!

**Benchmark Overview**

MeasureThat.net is hosting a benchmark comparing four string comparison methods: `regex`, `startsWith`, `indexOf`, and `includes`. The test uses a custom-built dataset of 100,000 random strings to measure their performance.

**Tested Methods**

Here are the methods being compared:

1. **Regex (`regexStart` and `regexEnd`)**: Using regular expressions to search for a specific pattern in the string.
2. **startsWith**: Checking if the string starts with a specific value.
3. **indexOf**: Finding the index of the first occurrence of a specific value in the string.
4. **includes**: Checking if the string contains a specific value.

**Options Compared**

Each method has two variations:

* `regexStart` and `regexEnd` have different patterns to test:
	+ `regexStart`: `^test` (matches only if the string starts with "test")
	+ `regexEnd`: `/test$/` (matches only if the string ends with "test")
* `startsWith`, `indexOf`, and `includes` are tested without any variations, as their behavior is consistent.

**Performance Metrics**

The benchmark measures each method's performance in terms of **Executions Per Second (EPS)**, which represents how many times each method executes for a single second on a given device.

**Results**

Here are the top 6 results from the latest benchmark:

| TestName | EPS |
| --- | --- |
| indexOf end | 4648.50341796875 |
| indexOf start | 4648.80078125 |
| includes | 560.1578979492188 |
| startsWith | 555.5219116210938 |
| regex end | 297.1336364746094 |
| regex start | 272.0079040527344 |

**Performance Analysis**

Based on the results, here's a brief performance analysis:

* `indexOf` and `includes` are the fastest methods, with an EPS of over 4600.
* `startsWith` is slightly slower than the top two, but still relatively fast.
* The regex variants are significantly slower, likely due to the overhead of regular expression parsing and matching.

**Conclusion**

In conclusion, this benchmark highlights the performance differences between various string comparison methods in JavaScript. While the results may vary depending on specific use cases and hardware, it's clear that `indexOf` and `includes` are the fastest options for most scenarios. The regex variants, while useful for more complex pattern matching, should be used judiciously to avoid performance overhead.

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