Benchmark: for-in vs Object.keys.forEach vs Object.keys with for loop

Script Preparation code:

var obj = {
    'a': 1,
    'b': 2,
    'c': 3,
    'd': 4,
    'e': 5,
    'f': 6,
    'g': 7
};

Tests:

for-in
for (var i = 10000; i > 0; i--) { for (var key in obj) { if (obj.hasOwnProperty(key)) { console.log(obj[key]); } } }
Object.keys.forEach
for (var i=10000; i > 0; i--) { Object.keys(obj).forEach(key => console.log(obj[key])); }
Object.keys with for loop
for (var i=10000; i > 0; i--) { for (var key of Object.keys(obj)) { console.log(obj[key]); } }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

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

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 25 days ago):

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided benchmark compares the performance of three approaches for iterating over an object's keys in JavaScript:

1. **For-in loop**: This is a traditional way to iterate over an object's properties using the `for...in` loop.
2. **Object.keys() with foreach loop**: This method uses the `Object.keys()` function to get an array of the object's property names and then iterates over this array using a `foreach` loop (also known as an arrow function in modern JavaScript).
3. **Object.keys() with for loop**: Similar to the previous approach, but instead of using an arrow function, it uses a traditional `for` loop.

**Options Compared**

The benchmark compares the performance of these three approaches across multiple executions, providing insights into their relative speed and efficiency.

**Pros and Cons of Each Approach:**

1. **For-in Loop**:
	* Pros: Simple and widely supported.
	* Cons: Can be slower due to the overhead of iterating over the object's prototype chain.
2. **Object.keys() with foreach loop (Arrow Function)**:
	* Pros: Modern and efficient, as it avoids the overhead of `for...in` and is optimized by the JavaScript engine.
	* Cons: Requires support for arrow functions and `Object.keys()` in the browser or runtime environment.
3. **Object.keys() with for loop**:
	* Pros: Similar to the previous approach but uses a traditional `for` loop instead of an arrow function, which might be more familiar to some developers.
	* Cons: Less efficient than using an arrow function and has similar performance characteristics to the for-in loop.

**Library and Special JS Features**

In this benchmark, there is no specific library used. However, it's worth noting that `Object.keys()` is a part of the ECMAScript standard (ECMA-262), which means it's supported across most modern JavaScript environments.

No special JS features or syntax are required for this benchmark.

**Other Alternatives**

For iterating over an object's properties, other approaches could include:

1. **Using `for...in` with `hasOwnProperty()`**: This method can be faster than the original for-in loop approach but requires the use of `hasOwnProperty()` to filter out inherited properties.
2. **Using a traditional `for` loop with `Object.keys()`**: This method is similar to the second approach mentioned above, using an arrow function, but without the benefits of modern JavaScript features.

Keep in mind that these alternatives might have different performance characteristics depending on the specific use case and JavaScript environment.

In summary, this benchmark provides a useful comparison of three common approaches for iterating over an object's keys in JavaScript. The results can help developers choose the most efficient method for their specific use cases.

Latest run results:

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

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

Browser/OS: Chrome 83 on Mac OS X 10.12.6

View result in a separate tab

Test name	Executions per second
for-in	0.6 Ops/sec
Object.keys.forEach	0.5 Ops/sec
Object.keys with for loop	0.6 Ops/sec

Related benchmarks:

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

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

Created: 4 years ago by: Guest

Jump to the latest result

for-in

Object.keys.forEach

Object.keys with for loop

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 25 days ago):