Benchmark: JS Regex vs .startsWith vs .indexOf

HTML Preparation code:

<div></div>

AخA
 
<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)));
}

​x
 
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;
}

 
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;
}

 
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;
}

 
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;
}

 
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;
}

 
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;
}

 
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

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

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: 2 days ago)

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

Browser/OS: Chrome 136 on Windows

View result in a separate tab

Test name	Executions per second
regex start	569.8 Ops/sec
startsWith	1370.3 Ops/sec
regex end	289.5 Ops/sec
endsWith	860.9 Ops/sec
indexOf start	10606.7 Ops/sec
indexOf end	11877.0 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 7 months ago):

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

The provided benchmark is designed to compare the performance of different string manipulation methods: Regular Expressions (Regex), startsWith, and indexOf. The test cases cover various scenarios, including searching for a specific substring at the start or end of a string.

Benchmark Definition

The benchmark definition consists of two parts:

Script Preparation Code: This code sets up the environment for the benchmarks. It defines some global variables:
- window.regexStart and window.regexEnd: Regular expression patterns to match at the start and end of strings, respectively.
- window.match and window.matchLength: A string to search for and its length, respectively.
- window.data: An array of random strings generated using a custom function.
- TOTAL_STRINGS: The total number of strings in the data array.
Html Preparation Code: This is an empty HTML snippet that serves as a placeholder for the actual benchmarking code.

Individual Test Cases

There are six test cases, each with its own benchmark definition:

Regex Start: Tests the performance of using a regular expression to search for a pattern at the start of a string.
StartsWith: Tests the performance of using the startsWith method to check if a string starts with a specific substring.
Regex End: Tests the performance of using a regular expression to search for a pattern at the end of a string.
endsWith: Tests the performance of using the endsWith method to check if a string ends with a specific substring.
StartsWith: Same as above, but with a different string to search for.
Regex Start: Same as above, but with an additional layer of complexity.

Benchmark Results

The benchmark results show the performance of each test case across multiple executions per second (EPS) on a Chrome 129 browser running on a Mac OS X 10.15.7 system. The results are as follows:

TestName	ExecutionsPerSecond
indexOf end	20028.25390625
indexOf start	19962.216796875
endsWith	1907.3641357421875
startsWith	1848.285888671875
regex start	871.0967407226562
regex end	765.4481201171875

Analysis

The results show that:

indexOf is the fastest method for searching at both the start and end of a string.
startsWith and endsWith are slower than indexOf, but still relatively fast.
Regular Expressions (Regex) can be slow compared to the other methods, especially when searching at the start or end of a string.

In general, these results suggest that if you need to perform frequent string searches, using indexOf might be a better choice. However, if you need more control over the search pattern, Regular Expressions (Regex) can still be a viable option.

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

The provided benchmark is designed to compare the performance of different string manipulation methods: Regular Expressions (Regex), `startsWith`, and `indexOf`. The test cases cover various scenarios, including searching for a specific substring at the start or end of a string.

**Benchmark Definition**

The benchmark definition consists of two parts:

1. **Script Preparation Code**: This code sets up the environment for the benchmarks. It defines some global variables:
	* `window.regexStart` and `window.regexEnd`: Regular expression patterns to match at the start and end of strings, respectively.
	* `window.match` and `window.matchLength`: A string to search for and its length, respectively.
	* `window.data`: An array of random strings generated using a custom function.
	* `TOTAL_STRINGS`: The total number of strings in the data array.
2. **Html Preparation Code**: This is an empty HTML snippet that serves as a placeholder for the actual benchmarking code.

**Individual Test Cases**

There are six test cases, each with its own benchmark definition:

1. **Regex Start**: Tests the performance of using a regular expression to search for a pattern at the start of a string.
2. **StartsWith**: Tests the performance of using the `startsWith` method to check if a string starts with a specific substring.
3. **Regex End**: Tests the performance of using a regular expression to search for a pattern at the end of a string.
4. **endsWith**: Tests the performance of using the `endsWith` method to check if a string ends with a specific substring.
5. **StartsWith**: Same as above, but with a different string to search for.
6. **Regex Start**: Same as above, but with an additional layer of complexity.

**Benchmark Results**

The benchmark results show the performance of each test case across multiple executions per second (EPS) on a Chrome 129 browser running on a Mac OS X 10.15.7 system. The results are as follows:

| TestName | ExecutionsPerSecond |
| --- | --- |
| indexOf end | 20028.25390625 |
| indexOf start | 19962.216796875 |
| endsWith | 1907.3641357421875 |
| startsWith | 1848.285888671875 |
| regex start | 871.0967407226562 |
| regex end | 765.4481201171875 |

**Analysis**

The results show that:

* `indexOf` is the fastest method for searching at both the start and end of a string.
* `startsWith` and `endsWith` are slower than `indexOf`, but still relatively fast.
* Regular Expressions (Regex) can be slow compared to the other methods, especially when searching at the start or end of a string.

In general, these results suggest that if you need to perform frequent string searches, using `indexOf` might be a better choice. However, if you need more control over the search pattern, Regular Expressions (Regex) can still be a viable option.

Related benchmarks:

JS Regex vs .startsWith vs .indexOf (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: 6 years ago by: Registered User

Jump to the latest result