Benchmark: JS Regex vs .startsWith vs .indexOf long

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".repeat(10000);
var TOTAL_STRINGS = window.TOTAL_STRINGS = 100;

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; }
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; }

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

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 131 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
regex start	832037.4 Ops/sec
startsWith	2708114.5 Ops/sec
regex end	837592.7 Ops/sec
endsWith	2699334.2 Ops/sec
indexOf start	4597262.5 Ops/sec
indexOf end	3730672.8 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one year ago):

LLMs can make mistakes. Check important info.

### Benchmark Overview

The benchmark titled **"JS Regex vs .startsWith vs .indexOf long"** aims to compare the performance of various string search techniques in JavaScript, including regular expressions (`RegExp`), the `String.prototype.startsWith` method, and the `String.prototype.indexOf` method.

### Comparison Options

Here are the different options tested in this benchmark, along with their pros and cons:

1. **Regular Expressions (`RegExp`)**
   - **Test Cases:**
     - `regex test for start` (checks if a string starts with "test")
     - `regex test for end` (checks if a string ends with "test")
   - **Pros:**
     - Powerful and flexible for complex string patterns.
     - Can match patterns that may not be easily representable with simpler functions.
   - **Cons:**
     - Performance tends to be worse than simpler methods for straightforward string checks.
     - Regular expressions can be harder to read and maintain for developers not familiar with regex syntax.

2. **String.prototype.startsWith()**
   - **Test Cases:**
     - `startsWith` (checks if a string starts with "test")
     - `endsWith` (checks if a string ends with "test")
   - **Pros:**
     - Simple and clear API specifically for checking string prefixes and suffixes.
     - Generally faster than regex for these straightforward checks.
   - **Cons:**
     - Limited to checking only the start or end of a string, no pattern matching capability.

3. **String.prototype.indexOf()**
   - **Test Cases:**
     - `indexOf start` (checks if a string starts with "test")
     - `indexOf end` (checks if a string ends with "test")
   - **Pros:**
     - Versatile; already widely used and can check for occurrences of substrings anywhere in the string.
     - Works in older browsers, offering better compatibility if needed.
   - **Cons:**
     - The method can be less readable and intent is less clear compared to `startsWith` for prefix/suffix checks.
     - Slightly more overhead in terms of performance for simply checking starts/ends, compared to dedicated methods.

### Python Libraries Used

In this benchmark, there aren't any Python libraries involved as all tests are executed using JavaScript. The setup is fully within the JavaScript environment, leveraging JavaScript's inherent string and regex functionalities.

### Special JavaScript Features or Syntax

No advanced JavaScript features or syntactical constructs are specifically tested in this benchmark. The evaluation primarily revolves around established string manipulation methods, which are quite standard in the JavaScript language.

### Alternatives

While the methods tested in this benchmark cover key functionalities for string searching, other alternatives could include:

1. **String.prototype.includes()**
   - Checks for a substring's presence within a string, which might be preferred for certain use cases but is not focused solely on the start or end of the string.
   
2. **String.prototype.slice()**
   - Can be used in combination with equality checks for custom prefix/suffix verification, but would be more verbose.

3. **Locale-aware methods:**
   - Using methods like `String.prototype.localeCompare()` for comparisons that account for locale rules, although not directly related to string searching, may be beneficial in some internationalization contexts.

Overall, the benchmark serves to illustrate performance differences in string checking methodologies, enabling developers to choose the optimal approach based on their specific use cases.

Related benchmarks:

JS Regex vs .startsWith vs .indexOf long (version: 1)

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

Created: one year ago by: Guest

Jump to the latest result

regex start

startsWith

regex end

endsWith

indexOf start

indexOf end

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one year ago):