Benchmark: make map with entries vs for of

Script Preparation code:

var arr = Array.from({length: 1000000}).map((_,i)=>({id: i}));

Tests:

map with entries
new Map(arr.entries())
map with for of
const m = new Map(); for (let item in arr) { m.set(item.id, item); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
map with entries
map with for of

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the JavaScript microbenchmark on MeasureThat.net.

**Benchmark Definition**

The benchmark definition is provided in JSON format, which represents two test cases:

1. Creating a Map from an array using `Map.entries()`
2. Creating a Map from an array using a traditional `for...in` loop and `set()` method

These two approaches are being compared to measure their performance.

**Options Compared**

The two options being compared are:

* **Map.entries()**: This method creates a new Map instance from the entries of another iterable (in this case, the `arr` array). It's a concise way to create a Map with key-value pairs.
* **Traditional for...in loop and set() method**: This approach uses a traditional `for...in` loop to iterate over the array elements and sets each element as a key-value pair in the Map instance.

**Pros and Cons of Each Approach**

**Map.entries():**

Pros:

* Concise and expressive syntax
* Fast and efficient, since it leverages the underlying iterable's iteration logic

Cons:

* May have performance overhead due to the creation of an intermediate iterator object
* Limited control over iteration order (since it follows the underlying iterable's order)

**Traditional for...in loop and set() method:**

Pros:

* Provides fine-grained control over iteration order
* Can be more flexible when working with complex data structures

Cons:

* More verbose syntax, which can make code harder to read and maintain
* May have performance overhead due to the explicit looping logic

**Library Used**

None explicitly mentioned in this benchmark. However, it's worth noting that both `Map.entries()` and traditional `for...in` loops rely on internal browser libraries or engine optimizations.

**Special JavaScript Features/Syntax**

No special features or syntax are used in these test cases. The focus is solely on comparing the performance of two basic Map creation approaches.

**Other Alternatives**

If you're interested in exploring alternative approaches, here are a few:

* Using `Array.prototype.reduce()` to create a Map: `const m = arr.reduce((map, item) => map.set(item.id, item), new Map());`
* Using `reduce()` with an accumulator function and `set()` method: `const m = arr.reduce((m, item) => { m.set(item.id, item); return m; }, new Map());`

Keep in mind that these alternatives may have different performance characteristics or trade-offs compared to the original approaches.

Latest run results:

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

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

Browser/OS: Chrome 107 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
map with entries	4.8 Ops/sec
map with for of	5.5 Ops/sec

Related benchmarks:

make map with entries vs for of (version: 0)

Comparing performance of: map with entries vs map with for of

Created: one year ago by: Guest

Jump to the latest result

map with entries

map with for of

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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