Benchmark: String in Array: Set vs Object lookup vs IndexOf vs includes vs findIndex vs find v2

Script Preparation code:

var arr = [];
var i = 0;
while (i <= 10) arr[i] = ('' + i++);
var testSet = new Set(arr);
var testObj = {};
for (const a of arr) {
  testObj[a] = true;
}


var randomKeys = [];
i = 0;
while (i <= 50) {
 randomKeys.push(''+Math.round(Math.random(50000) + 5000));
  i++;
}

Tests:

indexOf
for (const key of randomKeys) {const index = arr.indexOf(key);}
includes
for (const key of randomKeys) {const index = arr.includes(key);}
find
for (const key of randomKeys) {const index = arr.find(item => item == key);}
findIndex
for (const key of randomKeys) {const index = arr.findIndex(item => item == key);}
set
for (const key of randomKeys) {const index = testSet.has(key);}
object lookup
for (const key of randomKeys) {const index = testObj[key];}

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
indexOf
includes
find
findIndex
set
object lookup

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 months ago)

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

Browser/OS: Chrome 132 on Windows

View result in a separate tab

Test name	Executions per second
indexOf	2628352.0 Ops/sec
includes	2521471.5 Ops/sec
find	1196102.2 Ops/sec
findIndex	1190836.6 Ops/sec
set	19929088.0 Ops/sec
object lookup	7929826.5 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what's being tested.

**Overview**

The benchmark compares the performance of six different approaches to find an element in an array:

1. `indexOf`
2. `includes`
3. `find` (using a callback function)
4. `findIndex` (using a callback function)
5. `set` (using a `Set` object)
6. "Object lookup" (directly accessing an object property)

**Test setup**

The test creates an array of 11 elements, each with a random key between 50000 and 55000. A separate set and object are created from this array.

**Approaches compared**

1. **indexOf**: Finds the index of the first occurrence of a value in the array.
2. **includes**: Returns `true` if the array includes the specified value, `false` otherwise.
3. **find**: Uses a callback function to find the first element that matches the condition.
4. **findIndex**: Similar to `indexOf`, but returns the index of the first occurrence instead of its value.
5. **set**: Checks if the set contains the specified value.
6. "Object lookup": Directly accesses an object property using the key.

**Pros and cons of each approach**

1. **indexOf**:
	* Pros: Simple, straightforward, and efficient for small arrays.
	* Cons: May be slow for large arrays due to its linear search algorithm.
2. **includes**:
	* Pros: Easy to use, fast, and inclusive (returns `true` for any match).
	* Cons: May be slower than `indexOf` or "Object lookup" for exact matches.
3. **find**:
	* Pros: Flexible and powerful, but may be slower due to the callback function overhead.
4. **findIndex**:
	* Pros: Similar to `indexOf`, but returns an index instead of a value.
5. **set**:
	* Pros: Fast for checking membership in a set, as it uses a hash table.
6. "Object lookup":
	* Pros: Fast and direct access to object properties using the key.

**Libraries used**

1. `Set`: A built-in JavaScript data structure that provides fast membership testing.
2. No external libraries are explicitly mentioned, but `find` and `findIndex` rely on the callback function syntax, which is a feature of modern JavaScript (ECMAScript 2015 and later).

**Special JS features or syntax**

The benchmark uses several advanced JavaScript features:

1. Arrow functions (`() => { ... }`)
2. Template literals (`'' + i++`)
3. Modern Array methods (`for...of`, `includes`, `find`, etc.)

Overall, the benchmark provides a good comparison of different approaches for finding elements in an array, highlighting the trade-offs between speed, simplicity, and flexibility.

Related benchmarks:

String in Array: Set vs Object lookup vs IndexOf vs includes vs findIndex vs find v2 (version: 0)

Comparing performance of: indexOf vs includes vs find vs findIndex vs set vs object lookup

Created: one year ago by: Guest

Jump to the latest result

indexOf

includes

find

findIndex

set

object lookup

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):