Benchmark: JS Regex vs .startsWith

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.startsWith(match) === 0; x += 1; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
regex start
startsWith
regex end
endsWith

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

**Benchmark Overview**

The benchmark measures the performance of four different string comparison methods: `regex.start`, `.startsWith()`, `.endsWith()`, and no comparison (i.e., comparing `0` to `str`). The test data consists of 100,000 randomly generated strings.

**Options Compared**

1. **`regex.start`**: Uses a regular expression with the `/^` anchor to match only the beginning of the string.
2. **`.startsWith()`**: A built-in method that checks if the string starts with a given value (in this case, the `match` property).
3. **`.endsWith()`**: A built-in method that checks if the string ends with a given value (in this case, the `match` property).
4. **No comparison** (i.e., comparing `0` to `str`). This test is included to measure the overhead of any non-zero comparisons.

**Pros and Cons**

1. **`regex.start`**:
	* Pros: Can be used to match only the beginning of the string, can be more efficient for larger strings.
	* Cons: Requires regular expression syntax, may be slower due to compilation time.
2. **`.startsWith()`**:
	* Pros: Built-in method, efficient for most cases, easy to read and maintain.
	* Cons: May not be optimized for performance in some browsers or versions.
3. **`.endsWith()`**:
	* Pros: Built-in method, efficient for most cases, easy to read and maintain.
	* Cons: Similar to `.startsWith()`, may not be optimized for performance in some browsers or versions.
4. **No comparison**:
	* Pros: Provides a baseline for any non-zero comparisons, can help isolate comparison overhead.
	* Cons: Not relevant for actual string comparisons, only serves as a control case.

**Library and Purpose**

The `window.regexStart` and `window.regexEnd` variables are used to create regular expressions that match the beginning and end of strings, respectively. The purpose of these variables is to provide a consistent and efficient way to perform substring matching in the test data.

No specific libraries are used beyond what's built into JavaScript (e.g., `.startsWith()`, `.endsWith()`).

**Special JS Feature or Syntax**

The benchmark uses no special features or syntax beyond standard JavaScript.

**Other Alternatives**

If you're interested in exploring alternative string comparison methods, consider:

1. **`.includes()`**: A built-in method that checks if a substring is present in a string.
2. **`String.prototype.localeCompare()`**: A method for comparing strings based on locale-specific rules.
3. **Regular expressions with other anchors** (e.g., `$`, `%`): Can be used to match specific positions or patterns within the string.

Keep in mind that each of these alternatives has its own pros and cons, and may not offer significant performance advantages over the methods tested here.

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/118.0

Browser/OS: Firefox 118 on Ubuntu

View result in a separate tab

Test name	Executions per second
regex start	430.6 Ops/sec
startsWith	337.4 Ops/sec
regex end	376.3 Ops/sec
endsWith	340.5 Ops/sec

Related benchmarks:

JS Regex vs .startsWith (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

Created: one year ago by: Guest

Jump to the latest result

regex start

startsWith

regex end

endsWith

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