Benchmark: JavaScript String Starts/Ends With String Comparisons - Playground

HTML Preparation code:

<div></div>

Script Preparation code:

const iterationNum = 250000;
const possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz";
const possibleLen = possible.length;

function getRandomIntInclusive(max, min = 1) {
  const minCeiled = Math.ceil(min);
  const maxFloored = Math.floor(max);
  return Math.floor(Math.random() * (maxFloored - minCeiled + 1) + minCeiled); // The maximum is inclusive and the minimum is inclusive
}

function makeRandomString(len, defaultWord = '') {
  let text = defaultWord;
  for(let i = 0; i < len; i++) {
    text += possible.charAt(getRandomIntInclusive(possibleLen, 0));
  }
  return text + defaultWord;
}

const testWord = window.testWord = makeRandomString(getRandomIntInclusive(10));
const allStrings = window.allStrings = new Array(iterationNum);
const numberOfStrings = window.numberOfStrings = iterationNum;

for(let i = 0; i < numberOfStrings; i++) {
    allStrings[i] = makeRandomString(getRandomIntInclusive(20), testWord);
}

Tests:

indexOf at end of sentence v1
let x = 0; const numberOfStrings = window.numberOfStrings; const allStrings = window.allStrings; const testWord = window.testWord; const testWordLen = testWord.length; while (x < numberOfStrings) { const str = allStrings[x]; str.indexOf(testWord) === str.length - testWordLen; x += 1; }
indexOf at end of sentence v2
let x = 0; const numberOfStrings = window.numberOfStrings; const allStrings = window.allStrings; const testWord = window.testWord; const testWordLen = testWord.length; while (x < numberOfStrings) { const str = allStrings[x]; str.length - str.indexOf(testWord) !== str.length + 1; x += 1; }
string endsWith
let x = 0; const numberOfStrings = window.numberOfStrings; const allStrings = window.allStrings; const testWord = window.testWord; while (x < numberOfStrings) { const str = allStrings[x]; str.endsWith(testWord); x += 1; }
Regex match ends with
let x = 0; const numberOfStrings = window.numberOfStrings; const allStrings = window.allStrings; const testWord = window.testWord; const testWordRegExp = new RegExp(`${testWord}$`); while (x < numberOfStrings) { const str = allStrings[x]; str.match(testWordRegExp); x += 1; }
indexOf starts with
let x = 0; const numberOfStrings = window.numberOfStrings; const allStrings = window.allStrings; const testWord = window.testWord; const testWordLen = testWord.length; while (x < numberOfStrings) { const str = allStrings[x]; str.indexOf(testWord) === 0; x += 1; }
search starts with
let x = 0; const numberOfStrings = window.numberOfStrings; const allStrings = window.allStrings; const testWord = window.testWord; const testWordLen = testWord.length; while (x < numberOfStrings) { const str = allStrings[x]; str.search(testWord) === 0; x += 1; }
string startsWith
let x = 0; const numberOfStrings = window.numberOfStrings; const allStrings = window.allStrings; const testWord = window.testWord; while (x < numberOfStrings) { const str = allStrings[x]; str.startsWith(testWord); x += 1; }
Regex match starts with
let x = 0; const numberOfStrings = window.numberOfStrings; const allStrings = window.allStrings; const testWord = window.testWord; const testWordRegExp = new RegExp(`^${testWord}`); while (x < numberOfStrings) { const str = allStrings[x]; str.match(testWordRegExp); x += 1; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
indexOf at end of sentence v1
indexOf at end of sentence v2
string endsWith
Regex match ends with
indexOf starts with
search starts with
string startsWith
Regex match starts with

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll do my best to help!

Given the test results, it appears that there are some inconsistencies in the performance of different regex-related tests.

The latest benchmark result shows the following average execution per second (AEP) values for each test:

1. "Regex match starts with" - 122.81432342529297
2. "indexOf at end of sentence v1" - 3972.000732421875
3. "indexOf at end of sentence v2" - 3954.619140625
4. "indexOf starts with" - 3926.6494140625
5. "string endsWith" - 123.94133758544922
6. "string startsWith" - 123.66034698486328
7. "Regex match ends with" - 122.63227844238281

These values suggest that the regex-related tests are generally slower than the "indexOf at end of sentence" test, but there is some variation in performance between different test implementations.

To provide a more specific answer, I would need to see the actual code being executed for each test and the details of the regex patterns used. However, based on the provided data, here are some general observations:

* The "Regex match starts with" test seems to be the fastest, which is consistent with expectations since it only requires a single pass through the string.
* The "indexOf at end of sentence" tests appear to be significantly faster than the regex-related tests, likely due to their simplicity and efficiency.
* There may be some issues with the implementation of the "Regex match ends with" test, as it seems to be slower than the other regex-related tests.

If you'd like me to help troubleshoot specific issues or provide more detailed analysis, please let me know!

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36

Browser/OS: Chrome 122 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
indexOf at end of sentence v1	3972.0 Ops/sec
indexOf at end of sentence v2	3954.6 Ops/sec
string endsWith	123.9 Ops/sec
Regex match ends with	122.8 Ops/sec
indexOf starts with	3926.6 Ops/sec
search starts with	42.0 Ops/sec
string startsWith	123.7 Ops/sec
Regex match starts with	120.6 Ops/sec

Related benchmarks:

JavaScript String Starts/Ends With String Comparisons - Playground (version: 3)

Comparing performance of: indexOf at end of sentence v1 vs indexOf at end of sentence v2 vs string endsWith vs Regex match ends with vs indexOf starts with vs search starts with vs string startsWith vs Regex match starts with

Created: 9 months ago by: Registered User

Jump to the latest result

indexOf at end of sentence v1

indexOf at end of sentence v2

string endsWith

Regex match ends with

indexOf starts with

search starts with

string startsWith

Regex match starts with

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