Benchmark: filter ids with findIndex vs Map access

Tests:

findIndex
const questionIds = Array.from({length: 1000}, () => { const index = Math.floor(Math.random() * 1000); return {name: `test${index}`, id: index}; }); const allQuestions = Array.from({length: 1000}, (_, i) => { const index = i + 1; return {name: `test${index}`, id: index}; }); const selectedQuestions = []; for (const questionId of questionIds) { const questionIdIndex = allQuestions.findIndex(question => question.id === questionId); if (questionIdIndex !== -1) { selectedQuestions.push(allQuestions[questionIdIndex]); } }
Map
const questionIds = Array.from({length: 1000}, () => { const index = Math.floor(Math.random() * 1000); return {name: `test${index}`, id: index}; }); const allQuestions = Array.from({length: 1000}, (_, i) => { const index = i + 1; return {name: `test${index}`, id: index}; }); const questionMap = new Map(); allQuestions.forEach(origQuestion => { questionMap.set(origQuestion.id, origQuestion); }); const tmpQuestions = []; questionIds.forEach(questionId => { if (questionMap.has(questionId)) { const question = questionMap.get(questionId); tmpQuestions.push(question); } });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
findIndex
Map

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'll break down the provided benchmark and explain what's being tested, compared, and analyzed.

**Benchmark Overview**

The benchmark compares two approaches to find the index of an element in an array:

1. Using `findIndex` method
2. Creating a Map data structure and using its `has` and `get` methods

**FindIndex Method**

The first test case uses the `findIndex` method, which iterates through the `allQuestions` array to find the index of each `questionId`. The `findIndex` method returns the index of the first element that satisfies the provided callback function.

Pros:

* Simple and straightforward implementation
* Easy to understand and maintain

Cons:

* It requires iterating through the entire array, which can be slow for large datasets

**Map Approach**

The second test case uses a Map data structure to store the `allQuestions` array. The Map is created by setting each question's id as a key and its corresponding object as the value.

Pros:

* Fast lookup and retrieval of elements using the Map's `has` and `get` methods
* Can handle large datasets efficiently

Cons:

* Requires creating an additional data structure (the Map)
* May have higher memory overhead compared to other approaches

**Library: Lodash**

The `findIndex` method is a built-in JavaScript method, but the `Map` approach uses a common utility library called Lodash. In this context, Lodash's `Map` implementation is used as a placeholder, as the actual implementation of the Map data structure is specific to each browser.

**Special JS Feature/Syntax: None**

There are no special JavaScript features or syntaxes being tested in this benchmark.

**Other Alternatives**

Alternative approaches to find the index of an element in an array could include:

* Using `forEach` and indexing into the array
* Creating a regular expression for pattern matching
* Using a library like jQuery's `index()` method

However, these alternatives are likely to be slower or more cumbersome than using the built-in `findIndex` method or the Map approach.

**Benchmark Preparation Code**

The benchmark preparation code is provided in the "Script Preparation Code" field of each test case. This code creates two arrays: `questionIds` and `allQuestions`, which contain random question IDs and corresponding objects with name and id properties. The script then defines a loop that iterates through the `questionIds` array, finds the index of each element in the `allQuestions` array using `findIndex` or Map approach, and pushes the matched elements into a new array called `selectedQuestions`.

**Latest Benchmark Result**

The latest benchmark result shows the raw UA string, browser, device platform, operating system, executions per second for both test cases. The results indicate that the Map approach is faster than the `findIndex` method, which aligns with the expected performance characteristics of these approaches.

Related benchmarks:

filter ids with findIndex vs Map access (version: 0)

Comparing performance of: findIndex vs Map

Created: 3 years ago by: Guest

Jump to the latest result

findIndex

Map

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