Benchmark: map foreach vs array lookup vs const of

Script Preparation code:

var arr = [];
var map = new Map();

for (let i = 0; i < 12000; i++) {
  const num = i * 7 + Math.ceil(Math.random() * 5); 
  const str = (Math.random() + 1).toString(36).substring(7);
  arr.push(num);
  map.set(num, str);
}

Tests:

arr to map lookup
for (let i = 0;i < arr.length; i++) { let num = arr[i]; let str = map.get(num) || ''; }
map foreach
map.forEach((el)=>{})
map const of
for (const str of map) { let str32 = str[1]}

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
arr to map lookup
map foreach
map const of

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 92 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
arr to map lookup	351.7 Ops/sec
map foreach	8917.4 Ops/sec
map const of	13071.9 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 provided benchmarking results.

**Benchmark Overview**

The provided JSON represents a JavaScript microbenchmark, where users can create and run various benchmark tests. The benchmark is designed to compare three different approaches: using `foreach` on a `Map`, using `forEach` on an array-like object (not an actual array), and using direct array lookup with the `[key]` syntax.

**Options Compared**

The three options being compared are:

1. **map.forEach**: This approach uses the `forEach` method on the `Map` object, which iterates over its entries.
2. **arr to map lookup**: This approach directly looks up values in the `Map` using the `[key]` syntax.
3. **map const of**: This approach uses the spread operator (`...`) with the `const` keyword to extract values from the `Map`.

**Pros and Cons of Each Approach**

1. **map.forEach**:
	* Pros: Simple, readable, and efficient for large datasets.
	* Cons: May be slower due to object iteration and method call overhead.
2. **arr to map lookup**:
	* Pros: Fastest and most lightweight approach, as it directly accesses the `Map` values using the `[key]` syntax.
	* Cons: May not work correctly if the key is not present in the map, leading to undefined behavior or crashes.
3. **map const of**:
	* Pros: Concise and expressive way to extract values from a Map.
	* Cons: May be slower due to object iteration and method call overhead.

**Library and Syntax Used**

The `Map` data structure is used in the benchmark, which is a built-in JavaScript object that stores key-value pairs. The `[key]` syntax is also used to directly access values in the map.

No special JavaScript features or syntax are required for this benchmark.

**Other Alternatives**

There are other approaches to iterate over a Map, such as using `for...of` loop with `entry` iterator:

```javascript
for (const [key, value] of map) {
  // do something with key and value
}
```

This approach is more concise than `forEach`, but may be slower due to object iteration and method call overhead.

In conclusion, the benchmark highlights the trade-offs between different approaches when working with JavaScript Maps. The choice of approach depends on performance, readability, and maintainability requirements.

Related benchmarks:

map foreach vs array lookup vs const of (version: 0)

Comparing performance of: arr to map lookup vs map foreach vs map const of

Created: 3 years ago by: Guest

Jump to the latest result

arr to map lookup

map foreach

map const of

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):