Benchmark: findIndex vs forEach until final

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
arr.findIndex((itm) => itm.id === foo);
ForEach
arr.forEach((value) => { if (value.id === foo) { } });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
findIndex
ForEach

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.

Measuring the performance of two different approaches to find an element in an array: `findIndex` and `forEach`. Let's break down what's being tested.

**Benchmark Definition**
The benchmark is defined as an array with 15,000 elements, where each element has a unique `id` property. The array is initialized with a random `foo` value between 0 and 14,999.

**Script Preparation Code**
The script prepares the array by filling it with objects having `id` properties, then maps over the array to update the `id` properties of each object.

**Html Preparation Code**
There is no HTML preparation code provided.

**Test Cases**
Two test cases are defined:

1. **findIndex**: Tests the `findIndex` method, which returns the index of the first element in the array that satisfies the given condition (in this case, `value.id === foo`).
2. **ForEach**: Tests the `forEach` method, which iterates over the array and performs an action on each element.

**Library**
In the script preparation code, the `map` function is used, which is a built-in JavaScript method that creates a new array with the results of applying a provided function to every element in the calling array. The `map` function uses the V8 JavaScript engine's optimizations under the hood.

**Special JS Feature/ Syntax**
There are no special JS features or syntax used in this benchmark.

**Pros and Cons of Approaches**

* **findIndex**: Pros:
	+ Efficient, as it only needs to iterate over the array until finding a match.
	+ Can return early if the condition is not met for any element.
	Cons:
	+ May be slower due to its optimized implementation under the hood (V8 engine).
* **ForEach**: Pros:
	+ Easy to implement and understand.
	+ Can be faster in some cases, especially when dealing with very large arrays or custom logic.
Cons:
	+ Requires iterating over the entire array, which can lead to slower performance compared to `findIndex`.
	+ Returns undefined if no element matches the condition.

**Other Alternatives**

* **indexOf**: Another method that returns the index of the first occurrence of a specified value. It's similar to `findIndex` but uses the `indexOf` function internally.
* **Array.prototype.some()**: A method that tests whether at least one element in an array satisfies a provided condition. It can be faster than `forEach` for large arrays, as it stops iterating as soon as a match is found.

Keep in mind that the performance differences between these approaches may vary depending on the specific use case and JavaScript engine optimizations.

Related benchmarks:

findIndex vs forEach until final (version: 0)

Comparing performance of: findIndex vs ForEach

Created: 2 years ago by: Guest

Jump to the latest result

findIndex

ForEach

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