Benchmark: For in vs Object.*.forEach vs Object.values vs for of Object.entries

Script Preparation code:

var obj = new Object()
var keys = (new Array(10000)).fill(0).map((x, i) => { return i + 1 })
keys.forEach((x) => { obj['prop' + x] = x })

Tests:

For In
for (var key in obj) { console.log(obj[key]); }
Object values
for(let value of Object.values(obj)){ console.log(value); }
Object keys forEach
Object.keys(obj).forEach(key => console.log(obj[key]));
Object entries forEach
Object.entries(obj).forEach(([key, value]) => console.log(key,'->',value));
object values forEach
Object.values(obj).forEach(value => console.log(value));
for of Object.entries
for(let [key,value] of Object.entries(obj)){ console.log(value); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
For In
Object values
Object keys forEach
Object entries forEach
object values forEach
for of Object.entries

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 134 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
For In	71.2 Ops/sec
Object values	69.8 Ops/sec
Object keys forEach	72.6 Ops/sec
Object entries forEach	54.9 Ops/sec
object values forEach	73.8 Ops/sec
for of Object.entries	65.3 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided JSON represents a JavaScript microbenchmark, specifically measuring the performance of different iteration methods in a JavaScript context. The benchmark compares the execution time of four approaches:

1. **For...in**: Iterates over an object's properties using the `for...in` loop.
2. **Object.values()** and **forEach()**: Iterates over an object's values using the `Object.values()` method followed by a `forEach()` loop.
3. **Object.keys().forEach()**: Iterates over an object's property keys using the `Object.keys()` method followed by a `forEach()` loop.
4. **for...of** and **Object.entries().forEach()**: Iterates over an object's properties using the `for...of` loop followed by a `forEach()` call on the result of `Object.entries()`.

**Option Comparison**

Here's a brief overview of each option:

*   **For...in**: This is one of the most common ways to iterate over an object in JavaScript. It has some drawbacks, however:
    *   It iterates over both property names and values.
    *   It does not guarantee a specific order for property iteration (e.g., alphabetical or insertion order).
    *   Some objects may have inherited properties that could lead to unexpected behavior.

*   **Object.values()** and **forEach()**: This combination is often used when you need to process only the object's own values. However:
    *   It doesn't iterate over property keys; instead, it returns an array of all property values.
    *   If your object has inherited properties or symbols (which are not supported by `Object.values()`), they won't be included in this iteration.

*   **Object.keys().forEach()**: Similar to the previous option but iterates over property names:
    *   It doesn't iterate over property values.
    *   The same issue with inheritance and symbols as before.

*   **For...of** and **Object.entries().forEach()**: This pair is particularly interesting because it leverages modern JavaScript features for efficient iteration. It does, however, have some limitations:
    *   **For...of** only works on arrays or iterables; objects must be wrapped in an array or used with `Object.entries()` to iterate.
    *   If the object has symbols (which are not returned by `Object.entries()`) or other unexpected properties, they will be skipped.

**Pros and Cons**

*   **For...in**: Pros: Simple to implement. Cons: Unpredictable iteration order and potential for inclusion of inherited properties/symbols.
*   **Object.values()** and **forEach()**, **Object.keys().forEach()**: Pros: More predictable results regarding property access (no keys/symbols from inheritance). Cons: Lack of control over iteration order, no support for symbols, and may skip certain objects' own properties if those have inherited properties or are not enumerable.
*   **For...of** and **Object.entries().forEach()**: Pros: Modern, efficient. Cons: Limited to arrays/iterables, potential exclusion of symbols/specific properties.

**Other Considerations**

When choosing an iteration method, consider the following:

*   Predictability: If you need control over which properties are accessed (e.g., considering inheritance or symbolic properties), stick with methods that allow more fine-grained access.
*   Code Readability and Maintainability: The choice of iteration should aim for simplicity and readability in your codebase.

For this specific benchmark, it appears the modern approaches (**Object.values()** + **forEach()**, **Object.keys().forEach()**) outperform the older method (**for...in**), possibly due to their ability to iterate more predictably over property names or values. The comparison for using **Object.entries().forEach()** and **For...of** shows its potential as a modern approach but depends on specific requirements.

**Alternatives**

Other alternatives that may be worth considering:

*   **for...of** with a custom iterable: While it doesn't directly apply to objects, this can offer more control over iteration for array-like objects or other iterables.
*   **map()**, **filter()**, or **reduce()**: Methods like these might simplify certain operations in the object's values or keys by applying transformations before processing them.

However, considering the specific nature of this benchmark and its focus on direct property access/iteration (rather than filtering, mapping, or transforming data), sticking with the original methods seems most relevant.

Related benchmarks:

For in vs Object.*.forEach vs Object.values vs for of Object.entries (version: 0)

Comparing performance of: For In vs Object values vs Object keys forEach vs Object entries forEach vs object values forEach vs for of Object.entries

Created: 2 years ago by: Guest

Jump to the latest result

For In

Object values

Object keys forEach

Object entries forEach

object values forEach

for of Object.entries

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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