Benchmark: Map vs forEach - MeasureThat.net

Tests:

Map
const createLists = (arr = []) => { const listMap = new Map(); for (const val of arr) { if (!listMap.has(val)) { listMap.set(val, [val]); continue; } listMap.get(val).push(val); } return Array.from(listMap.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

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**Benchmark Definition**

The provided JSON represents two benchmark definitions:

1. `Map vs forEach`: This is the overall name and description of the benchmark, which compares the performance of using a `Map` data structure versus iterating over an array using `forEach`.
2. `createLists(arr = []) => { ... }`: This is a JavaScript function that creates lists from an input array.
3. `function createLists(arr = []) { ... }`: This is another implementation of the same function, using `forEach`.

**Options Compared**

The benchmark compares two options:

1. **Map**: Using a `Map` data structure to group elements by their values.
2. **forEach**: Iterating over an array using `forEach`, which creates a new list with grouped elements.

**Pros and Cons of Each Approach**

**Map:**

Pros:

* Efficient use of memory, as it only stores unique keys (values) and their corresponding values in the map.
* Fast lookups, as the map uses a hash table internally.

Cons:

* Can be slower for very large datasets due to the overhead of creating a map and performing lookups.
* May not be suitable for cases where the order of elements matters.

**forEach:**

Pros:

* Simple and straightforward implementation.
* Works well for small to medium-sized datasets.

Cons:

* Can lead to slow performance for large datasets due to the need to iterate over the entire array on each iteration.
* Creates a new list with duplicate values, which can be memory-intensive.

**Library Used**

In this benchmark, no libraries are explicitly mentioned. However, it's worth noting that `Map` is a built-in JavaScript data structure, while `forEach` is also a native method.

**Special JS Feature or Syntax**

The benchmark uses JavaScript functions and closures, but does not specifically highlight any advanced features like async/await, Promises, or modern syntax like arrow functions. The focus is on the performance comparison between two basic algorithmic approaches.

**Other Alternatives**

If you're interested in exploring other performance optimization techniques for similar problems, consider:

* Using a `Set` instead of a `Map` if the order of elements doesn't matter.
* Utilizing a library like Lodash or Ramda to simplify data manipulation and improve performance.
* Investigating more advanced data structures like arrays with built-in grouping methods (e.g., `Array.prototype.reduce()`).
* Examining the trade-offs between different algorithms for specific use cases, such as using a more efficient data structure but with higher memory usage.

Latest run results:

Run details: (Test run date: 3 years ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:86.0) Gecko/20100101 Firefox/86.0

Browser/OS: Firefox 86 on Windows

View result in a separate tab

Test name	Executions per second
Map	32319.3 Ops/sec
forEach	47775.2 Ops/sec

Related benchmarks:

Map vs forEach (version: 0)

Comparing performance of: Map vs forEach

Created: 8 years ago by: Guest

Jump to the latest result

Map

forEach

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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