Benchmark: Iterating map v2

Script Preparation code:

var map = new Map();
for (let i = 0; i < 1000; i++) {
  map.set(i, i);
}

Tests:

spread / map
let tuples = [...map].map(([k, v]) => [k, v]);
Array.from / entries() / map
let tuples = Array.from(map.entries()).map(([k, v]) => [k, v]);
Array.from / direct / map
let tuples = Array.from(map).map(([k, v]) => [k, v]);
Array.from / direct / nomap
let tuples = Array.from(map, ([k, v]) => [k, v]);
for loop
let tuples = []; for (let [k, v] of map) { tuples.push([k, v]); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
spread / map
Array.from / entries() / map
Array.from / direct / map
Array.from / direct / nomap
for loop

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Firefox 111 on Windows

View result in a separate tab

Test name	Executions per second
spread / map	14364.9 Ops/sec
Array.from / entries() / map	11339.5 Ops/sec
Array.from / direct / map	14688.1 Ops/sec
Array.from / direct / nomap	18936.6 Ops/sec
for loop	20038.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Definition JSON**

The benchmark definition provides the setup for the test case, including the creation of a Map object with 1000 entries using `var map = new Map();` and the preparation code to populate it. There are no HTML-specific preparation codes provided.

**Options Being Compared**

The benchmark tests different approaches for converting the Map object into an array of tuples:

1. **Spread Operator (`...map`)**: `let tuples = [...map].map(([k, v]) => [k, v]);`
2. **`Array.from()` with `.entries()` and `.map()`**: `let tuples = Array.from(map.entries()).map(([k, v]) => [k, v]);`
3. **`Array.from()` without `.map()`**: `let tuples = Array.from(map).map(([k, v]) => [k, v]);`
4. **`Array.from()` with a callback function that directly constructs the tuple**: `let tuples = Array.from(map, ([k, v]) => [k, v]);`
5. **For Loop**: `for (let [k, v] of map) { tuples.push([k, v]); }`

**Pros and Cons of Each Approach**

Here's a brief summary:

1. **Spread Operator (`...map`)**
	* Pros: Simple and concise.
	* Cons: May not be as efficient as other methods due to the extra function call and iteration over the array.
2. **`Array.from()` with `.entries()` and `.map()`**
	* Pros: Efficient, as it avoids unnecessary iterations and uses the built-in `entries()` method to get the entries of the Map.
	* Cons: May require more memory allocation due to creating an intermediate array.
3. **`Array.from()` without `.map()`**
	* Pros: Similar to the previous approach but with less overhead from the additional function call.
	* Cons: Still requires more memory allocation than other methods.
4. **`Array.from()` with a callback function that directly constructs the tuple**
	* Pros: Efficient and concise, as it avoids unnecessary iterations and uses a direct callback function to construct the tuples.
	* Cons: May be less readable due to the anonymous callback function.
5. **For Loop**
	* Pros: Simple and straightforward for those familiar with the syntax.
	* Cons: Generally slower than other approaches due to the overhead of the loop and the push method.

**Library: `Map`**

The Map object is a built-in JavaScript data structure that provides an efficient way to store key-value pairs. In this benchmark, the Map object is used as a collection of entries with integer keys and values.

**Special JS Feature: No special features are explicitly mentioned in the benchmark definition or test cases.**

**Benchmark Results**

The latest benchmark results show the execution speed for each approach:

* For Loop: 11339.4833984375 executions/second
* Array.from() with `.entries()` and `.map()` : 14364.8564453125 executions/second
* `Array.from()` without `.map()` : 14688.1259765625 executions/second
* Spread Operator (`...map`) : 18936.595703125 executions/second
* `Array.from()` with a callback function that directly constructs the tuple : 20038.033203125 executions/second

**Alternatives**

Other alternatives to test these approaches include:

1. **`reduce()`**: Using `array.reduce()` could be an alternative way to convert the Map object into an array of tuples.
2. **`forEach()` with a callback function that constructs the tuple**: Using `map.forEach()` with a callback function would achieve similar results, but might have performance implications due to the extra overhead.

These alternatives can provide more insights into the performance characteristics of each approach and may be worth testing on MeasureThat.net or other benchmarking platforms.

Related benchmarks:

Iterating map v2 (version: 1)

Comparing performance of: spread / map vs Array.from / entries() / map vs Array.from / direct / map vs Array.from / direct / nomap vs for loop

Created: one year ago by: Registered User

Jump to the latest result

spread / map

Array.from / entries() / map

Array.from / direct / map

Array.from / direct / nomap

for loop

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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