Benchmark: For in vs Object.*.forEach

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) { if (obj.hasOwnProperty(key)) console.log(obj[key]) }
Object values forEach
Object.values(obj).forEach(value => 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))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
For In
Object values forEach
Object keys forEach
Object entries forEach

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**What is being tested?**

MeasureThat.net is testing the performance of three different approaches for iterating over an object in JavaScript:

1. **For...in loop**: This approach iterates over an object's properties using the `for...in` loop, which returns both the property name and value.
2. **Object.values() + forEach()**: This approach uses the `Object.values()` method to get an array of an object's values, and then iterates over this array using the `forEach()` method.
3. **Object.keys() + forEach()**: This approach uses the `Object.keys()` method to get an array of an object's property names, and then iterates over this array using the `forEach()` method.
4. **Object.entries() + forEach()**: This approach uses the `Object.entries()` method to get an array of key-value pairs from an object, and then iterates over this array using the `forEach()` method.

**Options compared**

The three approaches (For...in loop, Object values+forEach(), and Object keys+forEach()) are being compared to determine which one is the most efficient.

**Pros and Cons:**

* **For...in loop**: This approach has a fixed iteration order, which may not be desirable in some cases. Additionally, it can iterate over inherited properties if the object's prototype also defines properties with the same names.
	+ Pros: Simple and straightforward, does not require additional libraries or methods.
	+ Cons: May not work as expected with objects that have inherited properties, and can lead to slower performance due to the fixed iteration order.
* **Object values + forEach()**: This approach uses a built-in method (Object.values()) to get an array of object values, which may be more efficient than iterating directly over the object's properties. However, it also creates an additional array that needs to be iterated over using another method (forEach()). Additionally, this approach requires JavaScript 2015+ syntax.
	+ Pros: May be faster than For...in loop due to using a built-in method, does not require additional libraries or methods.
	+ Cons: Requires modern JavaScript syntax (2015+), creates an additional array that needs to be iterated over.
* **Object keys + forEach()**: Similar to the previous approach, this uses a built-in method (Object.keys()) to get an array of object property names. However, it still requires another method (forEach()) to iterate over this array.
	+ Pros: May be faster than For...in loop due to using a built-in method, does not require additional libraries or methods.
	+ Cons: Requires modern JavaScript syntax (2015+), creates an additional array that needs to be iterated over.

**Additional considerations**

* The order of iteration is different for each approach. In some cases, this may matter, while in others it may not.
* Some objects (e.g., arrays) do not have a prototype chain and therefore will only iterate over their own properties.
* Some browsers may optimize or implement additional features for certain methods, which could affect the results.

**Library used**

None of the approaches use an external library. The built-in JavaScript `for...in` loop, `Object.values()`, `Object.keys()`, and `Object.entries()` methods are all part of the standard JavaScript language.

No special JS feature or syntax is used in this benchmark.

**Other alternatives**

There are other ways to iterate over objects in JavaScript, such as using a traditional `for` loop with an index variable:

```javascript
for (var i = 0; i < obj.length; i++) {
    var key = keys[i];
    console.log(obj[key]);
}
```

However, this approach is not compared in the benchmark.

Another alternative is to use `Object.keys()` and a traditional `forEach()` loop:

```javascript
keys.forEach(function(key) {
    Object.getPrototypeOf(obj).hasOwnProperty(key) && console.log(obj[key]);
});
```

This approach is also not compared in the benchmark.

Latest run results:

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

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

Browser/OS: Chrome 95 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
For In	9.0 Ops/sec
Object values forEach	9.4 Ops/sec
Object keys forEach	9.2 Ops/sec
Object entries forEach	7.2 Ops/sec

Related benchmarks:

For in vs Object.*.forEach (version: 0)

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

Created: 3 years ago by: Guest

Jump to the latest result

For In

Object values forEach

Object keys forEach

Object entries forEach

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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