Benchmark: Test forEach (findIndex) vs forEach (include)

Script Preparation code:

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

Tests:

SmallList ForEach => findIndex in BigList
smallIdList.forEach((itemId) => { const index = bigList.findIndex((bigListItem) => bigListItem.id === itemId); });
BigList ForEach => includes in SmallTestList
bigList.forEach((bigListItem, index) => { smallIdList.includes(bigListItem.id) });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
SmallList ForEach => findIndex in BigList
BigList ForEach => includes in SmallTestList

Fastest: N/A

Slowest: N/A

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/128.0.0.0 Safari/537.36

Browser/OS: Chrome 128 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
SmallList ForEach => findIndex in BigList	51.1 Ops/sec
BigList ForEach => includes in SmallTestList	87.7 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's being tested.

**Benchmark Overview**

The benchmark is designed to compare the performance of two approaches:

1. Using `forEach` with `findIndex` (BigList ForEach => findIndex in BigList)
2. Using `forEach` with `includes` (BigList ForEach => includes in SmallTestList)

**What's being tested?**

In both test cases, we have a large array `bigList` containing 15,000 elements with an `id` property, and a smaller array `smallIdList` containing 1,500 elements with random `id` values between 0 and 14,999. The goal is to find the index of each element in `smallIdList` that matches the `id` value in `bigList`.

**Options compared**

The two options being compared are:

A) Using `findIndex` within a `forEach` loop on `bigList`. This approach iterates through `bigList`, finds the index of each matching element using `findIndex`, and then iterates through the result to verify it matches an element in `smallIdList`.

B) Using `includes` within a `forEach` loop on `bigList`. This approach directly checks if each element in `bigList` is present in `smallIdList` by calling `includes` for each element.

**Pros and Cons of each approach**

A) Using `findIndex`:
	* Pros: Can be more efficient when the desired element is found, as it avoids unnecessary iterations.
	* Cons: Requires an extra iteration to verify the index against `smallIdList`, which can lead to slower performance for larger inputs.

B) Using `includes`:
	+ Pros: Often faster and more straightforward, especially for smaller arrays like `smallIdList`.
	+ Cons: Can be slower for large arrays or when the element is not found in `smallIdList`.

**Library used**

In both test cases, there is no explicit library mentioned. However, it's likely that JavaScript's built-in `Array.prototype.forEach` and `Array.prototype.includes` methods are being used.

**Special JS features or syntax**

There doesn't seem to be any special JavaScript features or syntax being used in this benchmark.

**Other alternatives**

Other approaches could include:

1. Using a separate function to find the index of an element in `bigList`, and then using that result with `forEach` on either array.
2. Using other optimization techniques, such as caching the results of `findIndex` or using a more efficient data structure like a hash table.

Keep in mind that the choice of approach depends on the specific use case and requirements. This benchmark provides a basic comparison of two common approaches to achieve this goal.

**Benchmark preparation code**

The provided script preparation code creates large arrays `bigList` and `smallIdList`, fills them with data, and then maps each element to an object with an `id` property. This ensures that both arrays have the same data structure, making it easier to compare their performance.

Related benchmarks:

Test forEach (findIndex) vs forEach (include) (version: 0)

Test forEach (findIndex) vs forEach (include)

Comparing performance of: SmallList ForEach => findIndex in BigList vs BigList ForEach => includes in SmallTestList

Created: one year ago by: Guest

Jump to the latest result

SmallList ForEach => findIndex in BigList

BigList ForEach => includes in SmallTestList

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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