Benchmark: Map iterator - MeasureThat.net

Script Preparation code:

var obj = {
  a: 1,
  b: 2,
  c: 3,
  d: 4,
  e: 5,
  f: 6,
  g: 7,
  h: 8,
  i: 9,
  j: 10,
  k: 11,
  l: 12,
  m: 13,
  n: 14,
  o: 15,
  p: 16,
  q: 17,
  r: 18,
  s: 19,
  t: 20,
  u: 21,
  v: 22,
  w: 23,
  x: 24,
  y: 25,
  z: 26
};
var map = new Map(Object.entries(obj));

Tests:

Map - for of kv
let total = 0; for (const [key, value] of map) { total += value; }
Map.values()
let total = 0; for (const entry of map.values()) { total += entry; }
Object.entries
let total = 0; for (const [key, value] of Object.entries(obj)) { total += value; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Map - for of kv
Map.values()
Object.entries

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.127 Safari/537.36

Browser/OS: Chrome 100 on Windows

View result in a separate tab

Test name	Executions per second
Map - for of kv	3023024.0 Ops/sec
Map.values()	5697023.0 Ops/sec
Object.entries	530541.4 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 and explore what's being tested on MeasureThat.net.

**Benchmark Definition**

The benchmark definition is provided in JSON format, which represents a script that sets up an object `obj` with 26 properties (a-z) and creates a new Map from it. The script then defines three test cases:

1. **Map - for of kv**: This test case iterates over the key-value pairs of the map using the `for...of` loop.
2. **Map.values()**: This test case iterates over the values of the map using the `map.values()` method.
3. **Object.entries**: This test case iterates over the key-value pairs of the object using the `Object.entries()` method.

**Options Compared**

The benchmark is comparing three different approaches to iterate over a data structure (Map or Object):

1. **`for...of` loop with map iterators**: This approach uses the `map` iterator to iterate over the key-value pairs of the map.
2. **`map.values()` method**: This approach uses the `map.values()` method to iterate over the values of the map.
3. **`Object.entries()` method**: This approach uses the `Object.entries()` method to iterate over the key-value pairs of the object.

**Pros and Cons**

Here's a brief summary of the pros and cons of each approach:

1. **`for...of` loop with map iterators**:
	* Pros: Generally faster and more efficient, as it avoids creating an intermediate array or using `map.values()`.
	* Cons: Requires understanding of the map iterator protocol and may not be suitable for all use cases.
2. **`map.values()` method**:
	* Pros: Easy to understand and implement, as it uses a well-known method to iterate over the values.
	* Cons: Creates an intermediate array, which can be slower than iterating directly over the map's iterator.
3. **`Object.entries()` method**:
	* Pros: Similar to using `for...of` loop with map iterators, but is more suitable for objects with fewer properties.
	* Cons: May not be as efficient as using a map iterator or `map.values()`, especially for large datasets.

**Libraries and Special JS Features**

None of the test cases use any external libraries. However, they do utilize some special JavaScript features:

1. **Map iterators**: The first test case uses the map iterator protocol to iterate over the key-value pairs of the map.
2. **`map.values()` method**: The second test case uses the `map.values()` method to iterate over the values of the map.

**Other Alternatives**

If you're looking for alternative approaches, consider the following:

1. **Using `forEach()` method on the map's iterator**: This approach is similar to using `for...of` loop with map iterators.
2. **Using `Array.from()` and `map()` methods**: This approach involves creating an array from the map's values and then iterating over it using `map()`.
3. **Using a custom loop or recursive function**: Depending on your specific use case, you might be able to implement a custom loop or recursive function that achieves similar performance to the benchmark.

Keep in mind that these alternatives may not provide identical results or may have different trade-offs in terms of performance, readability, and maintainability.

Related benchmarks:

Map iterator (version: 0)

Comparing performance of: Map - for of kv vs Map.values() vs Object.entries

Created: 2 years ago by: Guest

Jump to the latest result

Map - for of kv

Map.values()

Object.entries

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