Benchmark: Regex vs .indexOf vs .startsWith vs .substr (full)

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

LLMs can make mistakes. Check important info.

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

The provided benchmark tests the performance of different string manipulation methods: `Regex`, `.indexOf`, `.startsWith`, and `.substr (full)` (also known as substring extraction).

**Options being compared:**

1. **Regex**: Uses a regular expression to search for a pattern in a string.
2. **.indexOf**: Checks if a specified value is present at the beginning of a string using `str.indexOf(value)`.
3. **.startsWith**: Verifies if a string starts with a specified value using `str.startsWith(value)`.
4. **.substr (full)**: Extracts a substring from the original string using `str.substr(start, end)`.

**Pros and Cons of each approach:**

1. **Regex**:
	* Pros: Highly flexible, can match complex patterns, and is widely supported.
	* Cons: Can be slow due to the complexity of the pattern, may require additional resources for compilation, and has a steeper learning curve.
2. **.indexOf**:
	* Pros: Fast, simple, and easy to use.
	* Cons: Only checks for presence at the beginning of the string, not suitable for complex matching tasks.
3. **.startsWith**:
	* Pros: Similar to .indexOf but with a more specific check (starts with), faster than regular expressions, and easier to understand.
	* Cons: Not as flexible as Regex or .indexOf, may be less suitable for certain use cases.
4. **.substr (full)**:
	* Pros: Fast and efficient for substring extraction.
	* Cons: Only suitable for extracting a full substring; not ideal for searching or checking prefixes.

**Library used:**

In this benchmark, no libraries are explicitly mentioned, but the use of `RegExp` (regular expressions) is implied. The JavaScript engine's built-in support for regular expressions allows for efficient pattern matching.

**Special JS feature:**

None of the individual test cases explicitly use special JavaScript features like async/await, Promises, or destructuring. They rely on basic synchronous operations to execute the benchmarking logic.

**Benchmark preparation code analysis:**

The provided script preparation code sets up a JavaScript environment with a few constants and functions:

* `window.regex` defines a regular expression pattern `/^test/`.
* `window.match` assigns a test value `"test"` to be matched against strings.
* The `getRandomInt(max)` function generates random integers between 0 and `max-1`.
* The `makeRandomString(len)` function creates random strings with a specified length, using the string of possible characters (`possible`) and generating random indices.

These constants and functions are used to populate an array of random strings (`data`) and execute each test case in sequence. The `while` loop iterates over the total number of strings defined by `TOTAL_STRINGS`, ensuring consistent execution conditions across all test cases.

**Other alternatives:**

If you need alternative string manipulation methods or more specific use cases, consider exploring other options:

* For searching patterns in strings, look into libraries like `String.prototype.find()` or `String.prototype.includes()`.
* For substring extraction or prefix checking, use `.slice()` (substring extraction) or `.substr(0, length)` (prefix checking).
* For regular expression matching, explore the `RegExp` constructor and its options.

Keep in mind that each alternative has its own trade-offs and considerations. MeasureThat.net provides a convenient platform for exploring JavaScript microbenchmarks, but understanding the nuances of each approach will help you optimize your code for specific use cases.

Latest run results:

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

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

Browser/OS: Chrome 79 on Mac OS X 10.14.6

View result in a separate tab

Test name	Executions per second
Regex	300.7 Ops/sec
.indexOf	671.2 Ops/sec
.startsWith	127.7 Ops/sec

Related benchmarks:

Regex vs .indexOf vs .startsWith vs .substr (full) (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 28 days ago):