Benchmark: for-in vs for of vs object.keys vs object.entries

Script Preparation code:

var obj = {
  'a': 1,
  'b': 1,
  'c': 1,
  'd': 1,
  'e': 1,
  'f': 1,
  'g': 1
};

Tests:

for-in
let result; for (var key in obj) { result += obj[key]; }
Object.keys - forEach
let result; Object.keys(obj).forEach(key => { result += obj[key]; });
Object.keys - for loop
let result; const keys = Object.keys(obj); for (let i = 0; i < keys.length; i++) { result += obj[keys[i]]; }
for of - Object.keys
let result; for (const key of Object.keys(obj)) { result += obj[key]; }
for of - Object.entries
let result; for (const [key, value] of Object.entries(obj)) { result += value; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
for-in
Object.keys - forEach
Object.keys - for loop
for of - Object.keys
for of - Object.entries

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 10 months ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:139.0) Gecko/20100101 Firefox/139.0

Browser/OS: Firefox 139 on Mac OS X 10.15

View result in a separate tab

Test name	Executions per second
for-in	14495392.0 Ops/sec
Object.keys - forEach	8139622.5 Ops/sec
Object.keys - for loop	8995341.0 Ops/sec
for of - Object.keys	7687222.0 Ops/sec
for of - Object.entries	4747974.0 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

**Overview of the Benchmark**

The provided benchmark compares the performance of four different approaches to iterate over an object's properties:

1. `for-in`
2. `Object.keys` with `forEach`
3. `Object.keys` with a traditional `for` loop
4. `for...of` with `Object.keys`

**Approach 1: for-in**

* **Description**: The `for-in` loop iterates over an object's own enumerable properties using the property name as both the variable and the iteration value.
* **Pros**: Simple to write, easy to understand. Does not require explicit access to property values.
* **Cons**: Can be slower due to additional overhead for iterating over the property names.

**Approach 2: Object.keys - forEach**

* **Description**: `Object.keys` returns an array of a given object's own enumerable property names, and `forEach` iterates over this array using a callback function.
* **Pros**: Provides explicit access to property values and can be faster than `for-in`.
* **Cons**: Requires additional memory allocation for the array returned by `Object.keys`.

**Approach 3: Object.keys - traditional for loop**

* **Description**: This approach iterates over the property names returned by `Object.keys` using a traditional `for` loop.
* **Pros**: Similar to `Object.keys - forEach`, provides explicit access to property values and can be faster than `for-in`.
* **Cons**: Requires additional memory allocation for the array returned by `Object.keys`.

**Approach 4: for...of with Object.keys**

* **Description**: This approach uses a `for...of` loop with `Object.keys` as the iterator. The `for...of` loop iterates over an iterable (in this case, the property names returned by `Object.keys`) using its own variable.
* **Pros**: Provides explicit access to property values and is often faster than other approaches due to the optimization of the `for...of` loop.
* **Cons**: Requires modern JavaScript support.

**Library: Object.entries**

* **Description**: `Object.entries` returns an array of a given object's own enumerable key-value pairs, where each pair is an array with two elements (key and value).
* **Purpose**: Used as the iterator in Approach 4 (`for...of` with `Object.keys`).

**Special JS feature: No special features are used in this benchmark.**

**Other alternatives**

There are other ways to iterate over object properties, such as using a custom function or a library like Lodash. However, these approaches may not be relevant for this specific benchmark.

Some examples of alternative approaches:

* Using a custom function: `for (const key in obj) { ... }`
* Using Lodash: `_.forEach(obj.keys(), value => { ... })`

However, these alternatives are likely to have similar performance characteristics to the approaches being compared in this benchmark.

Related benchmarks:

for-in vs for of vs object.keys vs object.entries (version: 0)

Comparing performance of: for-in vs Object.keys - forEach vs Object.keys - for loop vs for of - Object.keys vs for of - Object.entries

Created: 3 years ago by: Guest

Jump to the latest result

for-in

Object.keys - forEach

Object.keys - for loop

for of - Object.keys

for of - Object.entries

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):