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

Test name	Executions per second
regex start	184.5 Ops/sec
startsWith	4668.0 Ops/sec
regex end	194.3 Ops/sec
endsWith	2837.2 Ops/sec
indexOf start	1760.4 Ops/sec
indexOf end	2887.1 Ops/sec
includes	3692.5 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.

Related benchmarks:

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

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