Benchmark: JavaScript: Regex vs .startsWith vs .indexOf

HTML Preparation code:

<div></div>

Script Preparation code:

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:

startsWith
window.data.forEach(str => str.startsWith(window.match));
endsWith
window.data.forEach(str => str.endsWith(window.match));
Regex start
var regex = /^test/; window.data.forEach(str => regex.test(str));
Regex end
var regex = /test$/; window.data.forEach(str => regex.test(str));
indexOf start
window.data.forEach(str => str.indexOf(window.match) === 0);
indexOf end
window.data.forEach(str => str.indexOf(window.match) === str.length - window.matchLength);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
startsWith
endsWith
Regex start
Regex end
indexOf start
indexOf end

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

This benchmark compares the performance of three string matching functions in JavaScript: `startsWith`, `endsWith`, and regular expressions (`regex`).

**What is tested?**

The benchmark tests how quickly each function can match a given string with another. The strings are generated randomly and uniformly from a set of possible characters (letters, digits, and punctuation). The functions being tested are:

1. `startsWith`: Checks if the string starts with a specified prefix.
2. `endsWith`: Checks if the string ends with a specified suffix.
3. Regular expression (`regex`): Uses a pattern to match any part of the string.

**Options compared:**

The benchmark compares two approaches for each function:

a. **Simple approach**: The function checks if the string starts/ends with the prefix/suffix using a simple `===` or `!==` comparison.
b. **Regular expression approach**: The function uses a regular expression to match the prefix/suffix.

**Pros and cons of each approach:**

1. **Simple approach**:
	* Pros:
		+ Easy to implement and understand.
		+ Fast, since it only involves a simple comparison.
	* Cons:
		+ May not be as efficient for large strings or complex patterns.
2. **Regular expression approach**:
	* Pros:
		+ Can match more complex patterns and is flexible.
		+ Can be optimized for performance using flags and caching.
	* Cons:
		+ More complicated to implement and understand.
		+ May be slower due to the overhead of compiling and executing the regular expression.

**Other considerations:**

1. **Regular expressions**: The benchmark uses two different regex patterns, one that starts with the prefix (`/^test/`) and another that ends with the suffix (`/$test$/`). This allows for a fair comparison between `startsWith` and `endsWith`.
2. **Character set**: The strings are generated from a uniform character set to ensure consistent results.

**Alternative approaches:**

1. **String.prototype.includes()**: An alternative approach for matching prefixes or suffixes, which is supported in modern browsers.
2. **Substring search algorithms**: Other algorithms, like KMP (Knuth-Morris-Pratt) or Boyer-Moore, can be used to improve performance for specific use cases.

Overall, this benchmark provides a useful comparison of the performance and efficiency of different string matching functions in JavaScript.

Latest run results:

Run details: (Test run date: 14 days ago)

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

Browser/OS: Chrome 130 on Windows

View result in a separate tab

Test name	Executions per second
startsWith	46.8 Ops/sec
endsWith	46.0 Ops/sec
Regex start	223.4 Ops/sec
Regex end	209.4 Ops/sec
indexOf start	43.6 Ops/sec
indexOf end	23.3 Ops/sec

Related benchmarks:

JavaScript: Regex vs .startsWith vs .indexOf (version: 0)

fork of https://www.measurethat.net/Benchmarks/Show/975/11/regex-vs-indexof-vs-startswith-vs-substr

Comparing performance of: startsWith vs endsWith vs Regex start vs Regex end vs indexOf start vs indexOf end

Created: 2 years ago by: Registered User

Jump to the latest result

startsWith

endsWith

Regex start

Regex end

indexOf start

indexOf end

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