Benchmark: 242022_string-compare

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:

.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
.indexOf
StartsWith

Fastest: N/A

Slowest: N/A

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/97.0.4692.99 Safari/537.36

Browser/OS: Chrome 97 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
.indexOf	7159.4 Ops/sec
StartsWith	503.4 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down what's being tested in the provided benchmark.

The main idea of this benchmark is to compare two string comparison methods: `indexOf` and `startsWith`. The test creates an array of random strings, stores it in the `window.data` variable, and defines a regular expression (`^test`) that will be matched against each string. The purpose of this setup is to simulate a scenario where you're searching for a specific pattern (the regex) within a collection of strings.

Here are the pros and cons of using `indexOf` versus `startsWith`:

**indexOf:**

Pros:

* More efficient when searching for an exact match.
* Can be faster for smaller strings, as it only needs to search from the start of the string.

Cons:

* Returns the index of the first occurrence of the specified value. If not found, it returns -1.
* Might be slower for larger strings or collections, as it has to iterate through the entire string to find a match.

**startsWith:**

Pros:

* More efficient when searching for an exact prefix within a string.
* Returns true if the specified value appears at the start of the string. If not found, it returns false.

Cons:

* Might be slower than `indexOf` because it needs to check every character in the string from the start.
* Can return false positives if the regex pattern is not unique (e.g., "test" and "tset").

In general, `startsWith` is a better choice when you want to search for a prefix within a string, while `indexOf` is more suitable for searching for an exact match.

Now, let's take a look at some additional aspects of the benchmark:

* The test uses `window.regex = /^test/;`, which defines a regular expression that will be used to match against each string in the array. This regex pattern matches any string that starts with "test".
* There is no special JavaScript feature or syntax being tested here, as both `indexOf` and `startsWith` are built-in methods.
* The benchmark doesn't skip any preamble code, so we've started from the beginning.

As for alternatives to these two string comparison methods, there are a few:

* **String.prototype.localeCompare()**: This method compares strings in a locale-specific way. While it's more advanced than `indexOf` and `startsWith`, it might be overkill for simple substring matching tasks.
* **Regular expressions with String.prototype.match() or String.prototype.search()**: You could use regular expressions to search for substrings within a string, but this approach can be slower and more verbose.

Overall, the benchmark provides a good test case for comparing the performance of `indexOf` and `startsWith`, which are essential methods in JavaScript's string manipulation arsenal.

Related benchmarks:

242022_string-compare (version: 0)

Testing some things

Comparing performance of: .indexOf vs StartsWith

Created: 2 years ago by: Guest

Jump to the latest result

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