Benchmark: Regex vs .indexOf vs .startsWith vs .substr

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) === true; x += 1; }
.substr
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.substr(0, match.length) === match; x += 1; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Regex
.indexOf
.startsWith
.substr

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 27 days ago):

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark and explain what's being tested, compared options, pros and cons, library usage, special JavaScript features or syntax, and alternatives.

**Benchmark Overview**

The provided benchmark tests four different string manipulation functions:

1. Regular Expressions (Regex)
2. `indexOf`
3. `startsWith`
4. `substr`

All tests create an array of random strings (`data`) and iterate through it, applying each function to a specific string (`str`).

**Compared Options**

Here's a brief comparison of the four options:

1. **Regex**: Uses a regular expression pattern to match a string. This approach provides high precision but can be slower due to the complexity of the regex engine.
2. **`.indexOf`**: Searches for a substring within a string and returns its index if found. This approach is generally faster than `Regex` because it uses a simpler algorithm, but it may not provide exact matches.
3. **`.startsWith`**: Checks if a string starts with another string. This approach is fast but only provides partial results (i.e., the starting match).
4. **`.substr`**: Extracts a substring from a given string. This approach is similar to `.indexOf`, but it extracts the matching substring instead of just its index.

**Pros and Cons**

Here's a brief summary of the pros and cons for each option:

1. **Regex**:
	* Pros: High precision, flexible patterns.
	* Cons: Slower performance due to regex complexity, may use more memory.
2. **`.indexOf`**:
	* Pros: Fast, simple algorithm.
	* Cons: May not provide exact matches, returns index instead of full match.
3. **`.startsWith`**:
	* Pros: Fast, provides partial result (starting match).
	* Cons: Limited to checking the starting character.
4. **`.substr`**:
	* Pros: Similar to `.indexOf`, but extracts the matching substring.
	* Cons: May be slower than a simple `indexOf` check.

**Library Usage**

None of the tests rely on external libraries, except for the JavaScript core functions used (e.g., `test()`, `charAt()`).

**Special JavaScript Features or Syntax**

No special features or syntax are used in this benchmark. All code follows standard JavaScript syntax and conventions.

**Alternatives**

Alternative approaches to these string manipulation functions include:

* Using other programming languages, like Python or C++.
* Implementing custom algorithms for faster performance (e.g., using SIMD instructions).
* Using specialized libraries or frameworks optimized for specific use cases (e.g., regex parsing).

Keep in mind that the choice of approach depends on the specific requirements and constraints of your project.

Latest run results:

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

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

Browser/OS: Chrome 85 on Mac OS X 10.15.6

View result in a separate tab

Test name	Executions per second
Regex	373.9 Ops/sec
.indexOf	6115.9 Ops/sec
.startsWith	494.2 Ops/sec
.substr	2344.7 Ops/sec

Related benchmarks:

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

Testing some things

Comparing performance of: Regex vs .indexOf vs .startsWith vs .substr

Created: 6 years ago by: Guest

Jump to the latest result

Regex

.indexOf

.startsWith

.substr

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 27 days ago):