Benchmark: Map.forEach vs Array.forEach vs Array.from(Map.values()).forEach

Script Preparation code:

var mapForEach = new Map();
var arr = [];
var mapToArr = new Map();

for (let i=0; i<100000; i++) {
  mapForEach.set(i, i);
  arr.push(i);
  mapToArr.set(i, i);
}

Tests:

Map.prototype.forEach
mapForEach.forEach(console.log);
Array.prototype.forEach
arr.forEach(console.log);
Array.from(Map.prototype.values()).forEach
Array.from(mapToArr.values()).forEach(console.log);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Map.prototype.forEach
Array.prototype.forEach
Array.from(Map.prototype.values()).forEach

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 25 days ago):

LLMs can make mistakes. Check important info.

Let's dive into the benchmark.

**What is being tested?**

The provided JSON represents a microbenchmark test that compares the performance of three different approaches:

1. `Map.prototype.forEach`
2. `Array.prototype.forEach`
3. `Array.from(Map.prototype.values()).forEach`

These approaches are compared in terms of their execution speed, measured in executions per second.

**Options compared:**

*   **`Map.prototype.forEach`**: This method is used to iterate over the values of a Map object.
*   **`Array.prototype.forEach`**: This method is used to iterate over an array of elements. Both `Map.prototype.forEach` and `Array.prototype.forEach` use similar syntax, but `forEach` on arrays is generally faster because it doesn't require creating an iterator object like `Map.prototype.forEach` does.
*   **`Array.from(Map.prototype.values()).forEach`**: This approach involves converting the values of a Map to an array using `Array.from()` and then calling `forEach()` on that array.

**Pros and Cons:**

*   **`Map.prototype.forEach`**:
    *   Pros: Can be useful when you need to iterate over the keys or entries of a Map.
    *   Cons: Generally slower than `Array.prototype.forEach` because it creates an iterator object.
*   **`Array.prototype.forEach`**:
    *   Pros: Fastest approach, suitable for iterating over arrays. Does not create any additional objects or iterators.
    *   Cons: Requires the elements to be iterated over to be stored in a collection before calling `forEach`.
*   **`Array.from(Map.prototype.values()).forEach`**:
    *   Pros: Does not require storing the elements to be iterated over in a collection before calling `forEach`. Suitable for large datasets.
    *   Cons: Creates an additional array object, which can lead to higher memory usage and potentially slower performance compared to native methods like `Array.prototype.forEach`.

**Library Usage:**

*   The benchmark uses `console.log` as the callback function for the `forEach()` method. This is a built-in JavaScript function and does not require any external libraries.
    *   Library: None

**Special JS Features or Syntax:**

*   The benchmark uses the `for...of` loop in the script preparation code but not in the individual test cases. However, it's worth noting that this loop has been supported in modern browsers for a long time.

**Alternatives:**

If you're looking to compare performance between these methods in your own tests, here are some alternatives:

*   Instead of using `Array.from(Map.prototype.values()).forEach`, you could use the native `Map.forEach()` method directly on the Map object.
    *   Example:
        ```
var map = new Map();
for (let i=0; i<100000; i++) {
  map.set(i, i);
}
map.forEach(function(value) {
  console.log(value);
});
```

*   For performance-critical code paths where the overhead of creating an iterator object is significant, consider using native methods like `Array.prototype.forEach()` or `Map.prototype.forEach()`.
    *   Example:
        ```
var arr = new Array(100000);
for (let i=0; i<arr.length; i++) {
  arr[i] = i;
}
arr.forEach(function(value) {
  console.log(value);
});
```

*   Keep in mind that while these alternatives may offer better performance, they should still be used judiciously and with a clear understanding of their trade-offs.

Latest run results:

Run details: (Test run date: 9 months ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36

Browser/OS: Chrome 120 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Map.prototype.forEach	3.7 Ops/sec
Array.prototype.forEach	4.3 Ops/sec
Array.from(Map.prototype.values()).forEach	4.2 Ops/sec

Related benchmarks:

Map.forEach vs Array.forEach vs Array.from(Map.values()).forEach (version: 0)

Comparing performance of: Map.prototype.forEach vs Array.prototype.forEach vs Array.from(Map.prototype.values()).forEach

Created: 9 months ago by: Guest

Jump to the latest result

Map.prototype.forEach

Array.prototype.forEach

Array.from(Map.prototype.values()).forEach

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 25 days ago):