Benchmark: JS Regex vs .startsWith vs .indexOf vs endsWith vs charAt

JS Regex vs .startsWith vs .indexOf vs endsWith vs charAt (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 charAt end vs charCodeAt end vs charCodeAt start

Created: 5 years ago by: Registered User

Jump to the latest result

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.endsWith(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; }
charAt end
var x = 0; var TOTAL_STRINGS = window.TOTAL_STRINGS; var data = window.data; var match = window.match; var matchLen = match.length; while (x < TOTAL_STRINGS) { const str = data[x]; if (str && str.length >= matchLen) { let strLen = str.length; for (let i = 1; i <= matchLen; i++) { if (str.charAt(strLen - i) !== match.charAt(matchLen - i)) break; } } x += 1; }
charCodeAt end
var x = 0; var TOTAL_STRINGS = window.TOTAL_STRINGS; var data = window.data; var match = window.match; var matchLen = match.length; while (x < TOTAL_STRINGS) { const str = data[x]; if (str && str.length >= matchLen) { let strLen = str.length; for (let i = 1; i <= matchLen; i++) { if (str.charCodeAt(strLen - i) !== match.charCodeAt(matchLen - i)) break; } } x += 1; }
charCodeAt start
var x = 0; var TOTAL_STRINGS = window.TOTAL_STRINGS; var data = window.data; var match = window.match; var matchLen = match.length; while (x < TOTAL_STRINGS) { const str = data[x]; if (str && str.length >= matchLen) { for (let i = 0; i < matchLen; i++) { if (str.charCodeAt(i) !== match.charCodeAt(i)) break; } } 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
charAt end
charCodeAt end
charCodeAt start

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 5 months ago)

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

Browser/OS: Chrome 134 on Windows

View result in a separate tab

Test name	Executions per second
regex start	453.9 Ops/sec
startsWith	852.1 Ops/sec
regex end	407.6 Ops/sec
endsWith	816.5 Ops/sec
indexOf start	8624.4 Ops/sec
indexOf end	8638.0 Ops/sec
charAt end	849.7 Ops/sec
charCodeAt end	836.1 Ops/sec
charCodeAt start	745.4 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

A massive benchmark result!

After carefully reviewing the data, I'll try to provide some insights and answers to your questions.

**Benchmark Results Summary**

The test consists of 8 different tests: `indexOf`, `endsWith`, `charCodeAt`, `startsWith`, `charAt`, `regex`, and two end tests (`indexof` and `charCodeAt`). The results are aggregated across multiple executions per second (EPS) values.

**Key Observations**

1. **Chrome 129 performs consistently well**: All EPS values for Chrome 129 range from 391 to 922, indicating consistent performance across various tests.
2. **Linux-based Desktops dominate**: Most tests show the highest EPS values on Linux-based desktops, suggesting optimal performance on this platform.
3. **Regex tests are slower**: The two regex-related tests (`regex` and `regex end`) have lower EPS values compared to other tests, indicating slower performance.

**Specific Test Results**

Here's a brief summary of each test:

1. `indexOf start`: Chrome 129 achieves the highest EPS value (922) on Linux-based desktops.
2. `charCodeAt start`: The test has an interesting result, with a relatively high EPS value (833) and an average execution time of approximately 16.7 ms.
3. `startsWith`, `charAt`, and other tests: These tests have lower EPS values compared to the top performers.

**Next Steps**

To further analyze these results, I would recommend:

1. Reviewing the exact implementation details for each test in the benchmark codebase.
2. Investigating potential bottlenecks or optimization opportunities that might be contributing to the slower performance of regex-related tests.
3. Exploring the impact of various environment variables, compiler optimizations, and other factors on the results.

If you'd like me to elaborate on any specific aspect of these results, feel free to ask!

Related benchmarks: