Benchmark: Regex vs .indexOf vs .startsWith vs includes

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

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Regex
.indexOf
.includes

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 break down the test cases and explain what is being tested, along with their pros and cons.

**Test Cases:**

1. **Regex**
	* The benchmark tests the performance of a regular expression (regex) pattern to match a specific string.
	* In this case, the regex pattern `window.regex = /^test/` is used to test whether the entire string matches the pattern.
	* The pros of using regex for this purpose include:
		+ Flexibility: Regex patterns can be complex and flexible, allowing for matching multiple characters or ranges.
		+ Performance: In some cases, regex can perform well, especially when dealing with large datasets.
	* However, the cons include:
		+ Complexity: Regex patterns can be difficult to read and maintain, especially for complex patterns.
		+ Performance overhead: Regex engines often introduce a performance overhead due to the complexity of the pattern evaluation process.
2. **.indexOf**
	* The benchmark tests the performance of the `indexOf()` method on strings.
	* In this case, the string is `window.match = 'test'`, and we're checking if the index of this string within the `data` array is 0 (i.e., the first occurrence).
	* The pros of using `.indexOf()` for this purpose include:
		+ Simplicity: The `.indexOf()` method is a straightforward and easy-to-understand operation.
		+ Performance: In many cases, `.indexOf()` can perform well, especially when dealing with large datasets.
	* However, the cons include:
		+ Limited functionality: `.indexOf()` only checks for exact matches within the string; it doesn't account for substring matches or regular expressions.
3. **.includes**
	* The benchmark tests the performance of the `includes()` method on strings.
	* In this case, we're checking if the string `window.match = 'test'` is present within the `data` array using the `.includes()` method.
	* The pros of using `.includes()` for this purpose include:
		+ Simplicity: Like `.indexOf()`, `.includes()` is a straightforward operation that checks for presence within a string.
		+ Performance: In many cases, `.includes()` can perform well, especially when dealing with large datasets.
	* However, the cons include:
		+ Limited functionality: Similar to `.indexOf()`, `.includes()` only checks for exact matches within the string; it doesn't account for substring matches or regular expressions.

**Library and Special JS Features:**

In this benchmark, we don't see any specific libraries being used beyond the standard JavaScript features. However, it's worth noting that the use of `window.data` and `window.match` suggests a custom setup for the test cases, which might be specific to the environment or requirements of MeasureThat.net.

**Other Considerations:**

When evaluating these test cases, we should also consider the following factors:

* **Cache performance:** How do the different operations interact with caching mechanisms in modern browsers? For example, does `.indexOf()` cache its results, while `regex` might not?
* **String normalization:** Are there any differences in how the browser handles string normalization between these three operations? (e.g., are all strings normalized to a standard format?)
* **Multi-threading and parallelism:** Does MeasureThat.net intentionally or unintentionally create opportunities for multi-threading or parallelism among these test cases?

**Alternatives:**

If you were to recreate this benchmark with alternative methods, here are some options:

1. **Use a more efficient regex engine:** Consider using a third-party regex library like Sregex or RegExr, which might provide better performance than the built-in JavaScript regex engine.
2. **Implement custom string matching algorithms:** Design and implement your own string matching algorithm, such as a simple suffix tree or trie-based approach, to compare with the existing methods.
3. **Use a more specialized library for string operations:** Consider using libraries like Lodash's `string` utilities or other specialized libraries that provide optimized string operations.

Keep in mind that these alternatives would require significant changes to the benchmark setup and test cases.

Latest run results:

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

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

Browser/OS: Chrome 100 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Regex	396.1 Ops/sec
.indexOf	4864.9 Ops/sec
.includes	324.7 Ops/sec

Related benchmarks:

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

Testing some things

Comparing performance of: Regex vs .indexOf vs .includes

Created: 2 years ago by: Guest

Jump to the latest result

Regex

.indexOf

.includes

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