Benchmark: Search in array of strings

Script Preparation code:

var str = '1234567';
var arr = [];
for (i = 0; i < 1000; i++) {
   arr.push([...Array(4 + Math.floor(Math.random() * 8))].map(i => (~~(Math.random() * 36)).toString(36)).join(''))
}

Tests:

IndexOf
arr.indexOf(str)
Includes
arr.includes(str)
ForEach with === with length check
arr.forEach(s => { if (s.length === str.length && s === str) console.log('Finded!'); })
ForEach with ===
arr.forEach(s => { if (s === str) console.log('Finded!'); })
ForEach with ==
arr.forEach(s => { if (s == str) console.log('Finded!'); })

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
IndexOf
Includes
ForEach with === with length check
ForEach with ===
ForEach with ==

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36 Edg/136.0.0.0

Browser/OS: Chrome 136 on Windows

View result in a separate tab

Test name	Executions per second
IndexOf	460155.5 Ops/sec
Includes	317222.4 Ops/sec
ForEach with === with length check	285828.7 Ops/sec
ForEach with ===	226563.8 Ops/sec
ForEach with ==	135990.2 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what is being tested, compared, and its pros and cons.

**Benchmark Definition:**
The benchmark measures how fast JavaScript can search for a specific string within an array of strings using four different approaches:

1. `arr.indexOf(str)`
2. `arr.includes(str)`
3. `arr.forEach(s => { ... });` with two variations:
	* Using the `===` operator (`s === str`)
	* Without the length check (`s == str`)

**Options Compared:**

* `arr.indexOf(str)` and `arr.includes(str)`: These two methods are designed to find a specific string within an array. However, they have different behaviors:
	+ `indexOf` returns the index of the first occurrence of the specified value, or -1 if it's not found. It also performs a case-sensitive search.
	+ `includes` returns a boolean indicating whether the array includes the specified value (case-insensitive). It's generally considered more readable and convenient than `indexOf`.
* `arr.forEach(s => { ... });`: This method iterates over each element in the array, which means it may potentially find the target string even if it's not at the beginning of the array.

**Pros and Cons:**

* Using `arr.indexOf(str)` or `arr.includes(str)`: These methods are optimized for their specific use cases. However:
	+ They can be slower than other approaches because they require iterating over the entire array to find the index or boolean result.
	+ They may not work correctly if the array is very large or has many duplicate values (due to performance issues with indexing).
* Using `arr.forEach(s => { ... });`: This method has a high overhead due to the iteration and conditional checks. However:
	+ It can be faster than `indexOf` or `includes` for small arrays, as it only needs to check each element once.
	+ It provides more flexibility, as you can use any logic inside the callback function.

**Library Used:**
The benchmark uses the built-in JavaScript `Array.prototype.indexOf()` and `Array.prototype.includes()` methods. These methods are optimized for performance but may not be suitable for all use cases (e.g., very large arrays or specific edge cases).

**Special JS Feature/Syntax:**
This benchmark does not explicitly test any special JavaScript features like `arrow functions`, `let`/`const` declarations, or other modern syntax.

**Alternative Approaches:**

* Instead of using `forEach`, you could use `Array.prototype.findIndex()` (introduced in ECMAScript 2015) to find the index of the first occurrence of the target string.
* For very large arrays, you might consider using a more specialized library or algorithm for searching and finding specific elements.

In summary, this benchmark measures how fast different approaches can search for a specific string within an array of strings. The results highlight the performance differences between `arr.indexOf(str)`/`arr.includes(str)`, `forEach` with and without equality checks, and the trade-offs in terms of readability, convenience, and potential performance.

Related benchmarks:

Search in array of strings (version: 0)

Comparing performance of: IndexOf vs Includes vs ForEach with === with length check vs ForEach with === vs ForEach with ==

Created: 5 years ago by: Guest

Jump to the latest result

IndexOf

Includes

ForEach with === with length check

ForEach with ===

ForEach with ==

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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