Benchmark: Regex vs .indexOf vs .startsWith xx

HTML Preparation code:

<div></div>

Script Preparation code:

window.regex = /^test/;
window.match = 'test';
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
var x = 0; var TOTAL_STRINGS = window.TOTAL_STRINGS; var data = window.data; var regex = window.regex; while (x < TOTAL_STRINGS) { const str = data[x]; regex.test(str); x += 1; }
.indexOf
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; }
.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); x += 1; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Regex
.indexOf
.startsWith

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!

**What is being tested?**

The provided benchmark tests three different approaches to search for a specific string within an array of random strings:

1. **Regex**: Using a regular expression to match the target string against each element in the `data` array.
2. **.indexOf**: Using the `indexOf()` method to find the index of the first occurrence of the target string in the `data` array.
3. **.startsWith**: Using the `startsWith()` method to check if the `data` array contains any strings that start with the target string.

**Options compared**

The benchmark is comparing the performance of these three approaches on a large dataset (100,000 random strings) across multiple executions (each with a different sequence of operations). The goal is to determine which approach is the fastest.

**Pros and cons of each approach:**

1. **Regex**:
	* Pros:
		+ Can be used to search for patterns, not just exact matches.
		+ Can be more flexible than other approaches.
	* Cons:
		+ Can be slower due to the complexity of regular expressions.
		+ May have performance issues with very large datasets or complex patterns.
2. **.indexOf**:
	* Pros:
		+ Fast and efficient for exact matches.
		+ Less memory-intensive than regex.
	* Cons:
		+ Only searches for exact matches, not approximate ones.
		+ May not perform well if the target string is not found in the dataset.
3. **.startsWith**:
	* Pros:
		+ Fast and efficient for checking prefixes.
		+ Less memory-intensive than regex.
	* Cons:
		+ Only searches for prefixes, not exact matches.
		+ May not perform well if the prefix is not found in the dataset.

**Library and its purpose**

The `getRandomInt` function generates a random integer between 0 and a specified maximum value. The `makeRandomString` function creates a random string of a specified length using ASCII characters (A-Z, a-z, 0-9).

**Special JS feature or syntax**

There is no special JavaScript feature or syntax mentioned in the benchmark code.

**Other alternatives**

If the benchmark were to include other approaches, some possibilities could be:

* **String.prototype.includes**: A more efficient version of `indexOf` that searches for any occurrence of the target string.
* **Array.prototype.some**: A method that checks if at least one element in an array satisfies a condition. Could be used to search for approximate matches.
* **Custom loop**: Implementing a custom loop using `for...of` or `while` loops could provide more flexibility but might also introduce performance overhead.

These alternatives would depend on the specific requirements and use cases of the benchmark.

Latest run results:

Run details: (Test run date: 4 years ago)

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

Browser/OS: Chrome 83 on Windows

View result in a separate tab

Test name	Executions per second
Regex	319.3 Ops/sec
.indexOf	5924.2 Ops/sec
.startsWith	342.9 Ops/sec

Related benchmarks:

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

Testing some things

Comparing performance of: Regex vs .indexOf vs .startsWith

Created: 4 years ago by: Guest

Jump to the latest result

Regex

.indexOf

.startsWith

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