Benchmark: Map vs forEach - MeasureThat.net

Tests:

Map
const createLists = (arr = []) => Array.from( arr.reduce((map, val) => { if (!map.has(val)) map.set(val, []); map.get(val).push(val); return map; }, new Map()).values() ); console.log(createLists([1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0]));
forEach
function createLists(arr = []) { let authors = []; let list = []; arr.forEach(item => { let authorIndex = authors.includes(item) ? authors.indexOf(item) : (authors.push(item) - 1); list[authorIndex] = list[authorIndex] || []; list[authorIndex].push(item); }); return list; } console.log(createLists([1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0]));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Map
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.

Let's break down the benchmark and its test cases.

**Benchmark Overview**

The benchmark compares two approaches to create an array of values with nested structure:

1. **Map**: Uses JavaScript's built-in `Map` data structure to store values and their indices, then converts it to an array using `Array.from()`.
2. **forEach**: Iterates over the input array using `forEach()` and creates an array by pushing values into a dynamically-sized array.

**Options Compared**

The two options being compared are:

1. **Map**: A more functional programming approach that uses a `Map` data structure to store values with their indices, allowing for efficient lookup and iteration.
2. **forEach**: An imperative approach using `forEach()` to iterate over the input array, creating an array by pushing values into a dynamically-sized array.

**Pros and Cons**

**Map:**

Pros:

* Efficient use of memory, as the `Map` stores only unique keys (values) with their indices.
* Fast iteration and lookup due to JavaScript's hash table implementation.

Cons:

* Requires the input array to be sorted or ordered in some way (in this case, all values are present), which may not always be the case.
* May have performance overhead due to the creation of a `Map` object.

**forEach:**

Pros:

* Can handle unsorted or unordered input arrays without modifications.
* Does not require the creation of an additional data structure (the `Map` in this case).

Cons:

* Has potential performance issues due to iterating over the entire array on each iteration, potentially leading to slow performance for large inputs.

**Other Considerations**

Both approaches have trade-offs between memory usage, iteration efficiency, and input order requirements. The choice of approach depends on the specific use case and requirements.

In this benchmark, the `Map` approach tends to outperform `forEach`, likely due to its efficient use of memory and fast iteration capabilities.

Now, let's talk about some JavaScript-specific features mentioned in the benchmark:

* **Array.from()**: A method that converts an array-like object into a true array.
* **Arrow functions** (`=>`): Used for concise function definitions, similar to traditional functions but with fewer keywords.

Note: The `forEach()` function is not a special JS feature per se, but rather a part of the standard JavaScript API.

Related benchmarks:

Map vs forEach (version: 0)

Comparing performance of: Map vs forEach

Created: 9 years ago by: Guest

Jump to the latest result

Map

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