Benchmark: Object iteration vs Map iteration

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 - forEach
let total = 0; map.forEach(function(value, key) { total += value; });
Object.entries() - for of kv
let total = 0; for (const [key, value] of Object.entries(obj)) { total += value; }
Object.entries() - forEach
let total = 0; Object.entries(obj).forEach(function(value, key) { total += value; });
Object - for in
let total = 0; for (const key in obj) { total += obj[key]; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

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

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 4 days ago)

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

Browser/OS: Chrome 135 on Windows

View result in a separate tab

Test name	Executions per second
Map - for of kv	2357317.8 Ops/sec
Map - forEach	1799745.0 Ops/sec
Object.entries() - for of kv	538445.8 Ops/sec
Object.entries() - forEach	96667.4 Ops/sec
Object - for in	5693803.5 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the benchmark and explain what's being tested, compared options, pros/cons, and other considerations.

**Benchmark Definition**

The provided JSON represents a JavaScript microbenchmark that compares the performance of iterating over an object using different methods:

1. `for...of` with `Map` objects
2. `forEach` with `Map` objects
3. `for...of` with `Object.entries`
4. `forEach` with `Object.entries`
5. `for...in` with objects

**Script Preparation Code**

The script preparation code creates an object `obj` with 26 properties and a corresponding `Map` object `map` by converting the object's entries to a map using `Object.entries(obj)`. This sets up the test environment for each benchmark.

**Html Preparation Code**

There is no HTML preparation code provided, which suggests that the tests are performed in a JavaScript-only environment.

**Individual Test Cases**

Each test case has a unique benchmark definition and name. Here's a brief explanation of what each test case does:

1. **Map - for of kv**: Iterates over the `map` object using `for...of`.
2. **Map - forEach**: Iterates over the `map` object using `forEach`.
3. **Object.entries() - for of kv**: Iterates over the entries of the `obj` object using `for...of`, which is achieved by calling `Object.entries(obj)`.
4. **Object.entries() - forEach**: Iterates over the entries of the `obj` object using `forEach`.
5. **Object - for in**: Iterates over the properties of the `obj` object using `for...in`.

**Comparison Options**

The benchmark compares the performance of these five iteration methods:

* `Map` objects with `for...of` and `forEach`
* Objects with `Object.entries()` and `for...of`, as well as `Object.entries()` and `forEach`

**Pros and Cons**

Here are some general pros and cons for each iteration method:

* **`for...of` with `Map` objects**: Pros: Fast, efficient, and easy to use. Cons: May not work well with large maps or complex data structures.
* **`forEach` with `Map` objects**: Pros: Similar performance to `for...of`. Cons: Less intuitive than `for...of`.
* **`for...of` with `Object.entries`**: Pros: Easy to use and fast. Cons: May not work well with large objects or complex data structures.
* **`forEach` with `Object.entries`**: Pros: Similar performance to `for...of`. Cons: Less intuitive than `for...of`.
* **`for...in` with objects**: Pros: Fast, but may not be as efficient as other methods for iterating over object properties. Cons: May iterate over inherited properties or properties in a different order.

**Other Considerations**

* When working with large data structures, the performance of iteration methods can vary depending on the JavaScript engine and browser being used.
* `Map` objects are generally faster than arrays when it comes to iteration, but may have slower startup times due to the overhead of creating a map.
* The choice of iteration method depends on the specific use case and personal preference.

**Alternatives**

Some alternative iteration methods that are not included in this benchmark include:

* Using `array.prototype.forEach()` or other array methods
* Using `WeakMap` objects instead of regular maps
* Using `TypedArray` objects for fast iteration over numeric data

Keep in mind that the performance characteristics of these alternatives may vary depending on the specific use case and JavaScript engine being used.

Related benchmarks:

Object iteration vs Map iteration (version: 0)

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

Created: 3 years ago by: Guest

Jump to the latest result

Map - for of kv

Map - forEach

Object.entries() - for of kv

Object.entries() - forEach

Object - for in

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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