Benchmark: Object iteration vs Map iteration V2

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
};

Tests:

Map - for of kv
var map = new Map(Object.entries(obj)); let total = 0; for (const [key, value] of map) { total += value; }
Map - forEach
var map = new Map(Object.entries(obj)); 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: 2 years ago)

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

Browser/OS: Chrome 106 on Windows 7

View result in a separate tab

Test name	Executions per second
Map - for of kv	149420.2 Ops/sec
Map - forEach	153582.0 Ops/sec
Object.entries() - for of kv	352277.3 Ops/sec
Object.entries() - forEach	68654.1 Ops/sec
Object - for in	211288.3 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 benchmarking world of JavaScript.

The provided JSON represents a set of benchmark tests for measuring the performance differences between various iteration methods in JavaScript: Object.entries(), Map, and Array-like objects with for-in loops.

**Options being compared**

1. **Object.entries() - for of kv**: Iterates over an object using the `for...of` loop syntax, which is a concise way to iterate over enumerable property key-value pairs.
2. **Object.entries() - forEach**: Uses the `forEach()` method on an array-like object returned by Object.entries(), allowing iteration over the properties in a functional style.
3. **Map - for of kv**: Iterates over a Map object using the `for...of` loop syntax, similar to Object.entries(). However, this is less common and not as efficient as using the forEach() method on Map entries.
4. **Map - forEach**: Uses the `forEach()` method on the entries of a Map object, providing an efficient way to iterate over key-value pairs.

**Pros and Cons**

*   **Object.entries() - for of kv**:
    *   Pros: concise syntax, easy to read and write, works with any iterable.
    *   Cons: performance may be slower compared to other methods due to the overhead of creating an iterator object.
*   **Object.entries() - forEach**:
    *   Pros: more control over iteration, allows using a callback function to process each item, works with any array-like object.
    *   Cons: may be less readable than for...of loop syntax, requires manual handling of the callback function.
*   **Map - for of kv**:
    *   Pros: easy to read and write, takes advantage of Map's built-in iterator support.
    *   Cons: less common usage compared to forEach() on Maps, may not be supported in older browsers or JavaScript versions.
*   **Map - forEach**:
    *   Pros: efficient iteration over key-value pairs, concise syntax for handling iterations with callback functions.
    *   Cons: assumes an array-like object (the entries), which can lead to performance issues if not optimized.

**Library and its purpose**

The `Object.entries()` method returns an array of a given object's own enumerable string-keyed property [key, value] pairs. The `Map` class provides methods to store key-value pairs in an unordered collection called a map (or dictionary).

**Special JS features or syntax**

The `for...of` loop is a newer iteration construct introduced in ECMAScript 2015 that allows iterating over values in an iterable object without using traditional indexing.

**Benchmark considerations and alternatives**

When choosing between these methods for performance-critical code, consider the following factors:

*   **Performance**: If you need optimal speed, `Map - forEach` might be a good choice. However, if readability is more important or you're willing to accept potential performance overhead, `Object.entries() - for of kv` could be a better fit.
*   **Readability and maintainability**: For codebases with multiple developers, using readable syntax like `for...of` loops can make the code easier to understand and modify.

For this benchmark, MeasureThat.net allows comparing the execution speed of different iteration methods. Other alternatives include:

*   Using profiling tools or libraries like [Benchmark.js](https://benchmarkjs.com/) to measure performance in your own projects.
*   Utilizing browser-specific profiling features, such as Chrome DevTools' "Profiling" tab or Firefox's "Performance" tab.
*   Implementing custom benchmarking scripts using languages like C++ for high-performance testing.

Keep in mind that measuring performance can be complex and depend on the specific use case. Always consider factors like system resources, data size, and iteration complexity when choosing an approach.

Related benchmarks:

Object iteration vs Map iteration V2 (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: 2 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 2 months ago):