Benchmark: startsWith vs indexOf

HTML Preparation code:


<div id=''></div>

Script Preparation code:

window.match = '=SUBTOTAL';
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:

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) === 0; x += 1; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
indexOf
startsWith

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

Let's dive into the benchmark and explore what's being tested.

**Benchmark Overview**

The benchmark compares the performance of two string comparison methods: `startsWith` and `indexOf`. The test case creates an array of 100,000 random strings, each with a length between 1 and 20. The goal is to measure which method is faster when searching for a specific prefix or substring at the beginning of each string.

**Benchmark Preparation Code**

The script preparation code initializes several variables:

* `window.match` and `window.matchLength` are set to empty strings, but in reality, these are supposed to be placeholders for the actual benchmarked function. This suggests that the actual implementation is not provided, but rather, a custom setup is expected.
* `window.data` is initialized as an array of random strings, generated using the `makeRandomString` function.
* `TOTAL_STRINGS` is set to 100,000.

**Individual Test Cases**

There are two test cases:

1. `indexOf`: This test case iterates over the `data` array and for each string, it checks if the `match` substring (empty) is at the beginning of the string using the `indexOf` method.
2. `startsWith`: Similar to the `indexOf` test case, but this time it uses the `startsWith` method to check if the `match` substring (also empty) is at the beginning of each string.

**Library Used**

Neither of the benchmarked methods directly uses a JavaScript library. However, it's worth noting that the `window.matchLength` assignment might be intended to set the length of the `match` variable for later use.

**Special JS Feature or Syntax**

None are explicitly mentioned.

**Benchmark Results**

The latest benchmark results show the execution rate per second for both test cases:

* `startsWith`: 401.0668640136719 executions/second
* `indexOf`: 297.58245849609375 executions/second

**Options Compared**

The two methods being compared are:

1. `startsWith`: Returns `true` if the string starts with the specified value.
2. `indexOf`: Returns the index of the first occurrence of the specified value in the string.

**Pros and Cons of Each Approach**

* `startsWith`:
	+ Pros: Can be faster for short prefixes, as it only needs to check a few characters.
	+ Cons: May not be suitable for longer prefixes or more complex searches, as it can lead to early returns with false positives.
* `indexOf`:
	+ Pros: Generally provides more accurate results, as it returns the actual index of the first occurrence.
	+ Cons: May require more computations, especially for larger strings or longer prefixes.

**Other Alternatives**

If `startsWith` and `indexOf` are not suitable for your use case, other alternatives might include:

* `includes`: Returns a boolean indicating whether the string includes the specified value. While similar to `startsWith`, it's more general-purpose.
* Custom implementations: Depending on the specific requirements, you might consider implementing a custom algorithm using bitwise operations or regular expressions.

Keep in mind that the choice of method ultimately depends on your specific use case and performance requirements.

Related benchmarks:

startsWith vs indexOf (version: 0)

Comparing performance of: indexOf vs startsWith

Created: 4 years ago by: Guest

Jump to the latest result

indexOf

startsWith

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):