Benchmark: Map foreach vs Object.keys.forEach

Script Preparation code:

var m = new Map();
var o = {};

void Array(1e2).fill().forEach(() => {
	void m.set(String(Math.random()), Math.random());
  	void (o[Math.random()] = Math.random());
});

Tests:

Map foreach
void m.forEach((k, v) => console.log(v));
Object keys forEach
Object.keys(o).forEach(key => console.log(o[key]))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Map foreach
Object keys forEach

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36

Browser/OS: Chrome 127 on Linux

View result in a separate tab

Test name	Executions per second
Map foreach	1167.8 Ops/sec
Object keys forEach	1090.4 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation of what's being tested in this benchmark.

The provided JSON represents two test cases, both measuring the performance difference between using `Map.forEach()` and `Object.keys().forEach()` to iterate over an object or a map (in this case, a map with string keys).

**Options being compared:**

1. **Map.forEach()**: This method is used to iterate over the key-value pairs of a Map object. It's equivalent to `Array.prototype.forEach()` but designed specifically for Maps.
2. **Object.keys().forEach()**: This method uses the `Object.keys()` function to get an array of a given object's property names, and then iterates over this array using the `forEach()` method.

**Pros and cons:**

*   **Map.forEach():**
    *   Pros:
        *   Designed specifically for Maps, which means it's likely optimized for performance.
        *   Easy to read and understand for developers familiar with Maps.
    *   Cons:
        *   Not as widely supported as `Object.keys().forEach()`, although this is not a significant concern since most modern browsers support Map objects.
*   **Object.keys().forEach():**
    *   Pros:
        *   Widely supported across different JavaScript engines and platforms, including older versions of Internet Explorer.
        *   Can be used with any object or array that supports `keyof T` (i.e., an object with string keys).
    *   Cons:
        *   Not as efficient for Maps because it involves unnecessary string comparisons and array iteration.

**Library usage:**

In this benchmark, none of the test cases explicitly uses a library. However, if you were to use libraries that provide optimized implementations for these methods, they might offer performance benefits:

*   **Lodash's `mapKeys()`**: Lodash provides an implementation for `map.keys()` in its `lodash.mapKeys()` function.
*   **Underscore.js's `_mapObject`**: Underscore.js has a `_mapObject()` function that can be used to iterate over objects.

**Special JavaScript features/syntax:**

There are no special JavaScript features or syntaxes being tested in this benchmark. However, it's worth noting that modern browsers and engines support `for...of` loops with iterators and destructuring, which might provide alternative ways to iterate over Maps and objects.

Here is a code example for `for...of` loop:

```javascript
// Map iteration using for-of loop
void Array(1e2).fill().forEach((entry) => {
    void (m.get(entry[0]) === undefined ? void 0 : m.set(entry[0], entry[1]));
});
```

**Other alternatives:**

Some other alternatives to compare the performance of `Map.forEach()` and `Object.keys().forEach()` could be:

*   **`Array.prototype.forEach()`**: This method iterates over an array, which is a different data structure than Maps.
*   **`Set` data structure**: Iterating over a Set can be another alternative, especially when dealing with unique values.

Keep in mind that each of these alternatives will have its own set of pros and cons, depending on the specific use case.

Related benchmarks:

Map foreach vs Object.keys.forEach (version: 0)

Map object forach vs Object.keys foreach

Comparing performance of: Map foreach vs Object keys forEach

Created: 4 years ago by: Guest

Jump to the latest result

Map foreach

Object keys forEach

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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