Benchmark: For in vs Object.keys for loop vs Object.keys.forEach

Script Preparation code:

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

Tests:

For In
for (var key in obj) { if (obj.hasOwnProperty(key)) console.log(obj[key]) }
Object keys forEach
Object.keys(obj).forEach(key => console.log(obj[key]))
Object keys For loop
for (let i = 0, keys = Object.keys(obj); i < keys.length; i++) { console.log(obj[keys[i]]); }

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

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested.

**Benchmark Definition**

The benchmark defines three test cases that compare different approaches to iterate over an object's properties:

1. **For In**: Uses the `for...in` loop to iterate over the object's properties.
2. **Object keys For loop**: Uses a traditional `for` loop with an array of property names obtained from `Object.keys()`.
3. **Object keys forEach**: Uses the `forEach()` method on the array of property names.

**Options Compared**

The benchmark compares the performance of these three approaches:

* **For In**: Iterates over the object's properties using a loop that checks for ownership (`obj.hasOwnProperty(key)`).
* **Object keys For loop**: Iterates over an array of property names obtained from `Object.keys()`. The loop uses an index to access each property value.
* **Object keys forEach**: Iterates over the same array of property names, but uses a callback function to execute on each iteration.

**Pros and Cons**

Here are some pros and cons for each approach:

1. **For In**:
	* Pros: Simple and concise syntax, no need to manually iterate over properties.
	* Cons: May have performance issues due to unnecessary checks (`obj.hasOwnProperty(key)`).
2. **Object keys For loop**:
	* Pros: Allows manual control over the iteration process and can be optimized for performance.
	* Cons: Requires extra steps to create the array of property names, which can add overhead.
3. **Object keys forEach**:
	* Pros: Simple and concise syntax, eliminates the need to manually iterate over properties.
	* Cons: May incur additional overhead due to the use of `forEach()` and its callback function.

**Library and Special JS Features**

The benchmark uses no external libraries or special JavaScript features besides the standard ones (e.g., `Object.keys()`, `forEach()`).

**Other Considerations**

When choosing an iteration approach, consider the following factors:

* Performance: If raw speed is crucial, using a traditional `for` loop with manual property iteration might be beneficial.
* Code readability and maintainability: The `For In` and `Object keys For loop` approaches can lead to more complex code due to the need to manage indices and checks for ownership.
* Browser support: All three approaches should work in modern browsers. However, some older browsers might have issues with certain methods or syntax.

**Alternatives**

If you're looking for alternative iteration approaches, consider:

* **Object.entries()**: A newer method that returns an array of key-value pairs, eliminating the need for manual property iteration.
* **Array.prototype.map()**: Can be used to create a new array of values from an object's properties.
* **Using a library or framework**: Depending on your project requirements and performance needs, you might consider using a library like Lodash or Ramda that provides optimized iteration functions.

Keep in mind that the choice of iteration approach ultimately depends on your specific use case, performance requirements, and personal preference.

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 119 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
For In	2719.5 Ops/sec
Object keys forEach	2593.2 Ops/sec
Object keys For loop	2930.7 Ops/sec

Related benchmarks:

For in vs Object.keys for loop vs Object.keys.forEach (version: 0)

Comparing performance of: For In vs Object keys forEach vs Object keys For loop

Created: 2 years ago by: Guest

Jump to the latest result

For In

Object keys forEach

Object keys For loop

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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