Benchmark: test findIndex vs includes vs map & indexOf

Script Preparation code:

var arr = new Array(15000);
arr.fill({ id: 0 });
arr = arr.map((el, idx) => el.id = idx);
var foo = Math.floor(Math.random() * 15000);

Tests:

findIndex
var index = arr.indexOf(foo);
includes
var index = arr.includes(foo);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
findIndex
includes

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

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

**What is being tested?**

The provided JSON represents a JavaScript microbenchmark that compares the performance of three different methods to find an element in an array:

1. `findIndex`
2. `includes`
3. Using `map` and `indexOf`

These methods are used to search for a specific value (`foo`) within the array (`arr`). The benchmark aims to determine which method is the most efficient.

**Options compared**

The three options being compared are:

1. **findIndex**: This method returns the index of the first occurrence of the specified value. If the value is not found, it returns `-1`.
2. **includes**: This method returns `true` if the array includes the specified value, and `false` otherwise.
3. **map** + **indexOf**: This approach involves using the `map` function to create a new array with the same values as the original array, but with an additional property (`id`) that increments for each element. Then, it uses the `indexOf` method to search for the value in the mapped array.

**Pros and cons of each approach**

1. **findIndex**: This method is generally the most efficient, as it only needs to traverse the array once to find the index of the value. However, if the value is not found, it returns `-1`, which may incur additional overhead.
2. **includes**: This method is simpler and faster than `findIndex` because it can short-circuit as soon as it finds the value, rather than traversing the entire array. However, it requires a single pass through the array to determine if the value exists.
3. **map** + **indexOf**: This approach involves creating a new array with additional properties, which can incur significant overhead due to memory allocation and copying. While `indexOf` is fast on its own, combining it with a mapping function makes this approach less efficient than the other two.

**Library usage**

None of the provided benchmark code uses any external libraries or frameworks.

**Special JavaScript features**

The benchmark does not use any special JavaScript features or syntax beyond standard ECMAScript features.

**Other alternatives**

Some alternative approaches that could be used to search for an element in an array include:

* Using `forEach` and checking for a boolean condition
* Using `reduce` with an initial value of `-1` and incrementing the index on each iteration until the value is found
* Using a binary search algorithm, which can be efficient for large arrays but requires additional overhead due to extra memory accesses.

However, these alternatives are not being tested in this specific benchmark.

Latest run results:

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

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

Browser/OS: Chrome 109 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
findIndex	676900.3 Ops/sec
includes	679413.4 Ops/sec

Related benchmarks:

test findIndex vs includes vs map & indexOf (version: 0)

Comparing performance of: findIndex vs includes vs map and indexOf

Comparing performance of: findIndex vs includes

Created: one year ago by: Guest

Jump to the latest result

findIndex

includes

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