Benchmark: findIndex vs forEach until final test2

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) { return 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.

I'd be happy to help you understand the provided benchmark.

**What is being tested?**

The provided benchmark tests two different approaches to find an element in an array: `findIndex` and `forEach`. The test array contains 15,000 elements with a unique identifier (`id`) assigned to each element using the `map()` function. A random index (`foo`) is generated to simulate searching for a specific element.

**Options being compared**

The two options being compared are:

1. **findIndex**: This method returns the index of the first element in the array that satisfies the provided callback function.
2. **forEach**: This method executes the provided callback function once for each element in the array, but it does not return a value.

**Pros and Cons**

* **findIndex**:
	+ Pros: More efficient when searching for a single specific element (returns an index), can be faster for large arrays due to its optimized implementation.
	+ Cons: Returns `undefined` if no element matches the callback function, which might lead to unexpected behavior in some cases.
* **forEach**:
	+ Pros: Can be useful when iterating over an array and performing multiple operations on each element (e.g., filtering, mapping).
	+ Cons: Not optimized for searching a single element; returns `undefined` if no elements match the callback function.

**Library usage**

None of the test cases use external libraries. The `map()` function is a built-in JavaScript method that creates a new array with the results of applying a provided function to each element in an existing array.

**Special JS feature or syntax**

No special JavaScript features or syntax are used in these test cases.

**Other alternatives**

There are other ways to find an element in an array, such as using `includes()`, but they may not be suitable for this specific use case (searching for a single element). Other options like `indexOf()` or `entries()` might also be considered, but their implementation and performance might vary.

**Benchmark preparation code**

The provided script preparation code creates an array of 15,000 elements with unique identifiers using the `map()` function. It then generates a random index (`foo`) to simulate searching for a specific element.

**Individual test cases**

The two test cases are:

1. **findIndex**: Tests the `findIndex` method by calling it with a callback function that checks if the current element's `id` property matches the generated random index.
2. **ForEach**: Tests the `forEach` method by calling it with a callback function that returns the value of the current element if its `id` property matches the generated random index.

**Latest benchmark result**

The provided benchmark result shows the execution frequency per second for each test case in Chrome 114 on a Windows Desktop:

* **findIndex**: approximately 1165.98 executions per second
* **ForEach**: approximately 1153.98 executions per second

Related benchmarks:

findIndex vs forEach until final test2 (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):