Benchmark: For in vs Object.*.forEach vs Object.values vs _.forEach(_.values v3

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/lodash/4.16.0/lodash.min.js"></script>

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));
_.forEach(_.values())
_.forEach(_.values(obj), value => 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
_.forEach(_.values())

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and its various test cases.

**Benchmark Overview**

The benchmark is designed to compare the performance of different ways to iterate over an object in JavaScript. The goal is to determine which approach is fastest, most efficient, and most readable.

**Script Preparation Code**

The script preparation code creates a large object with 10,000 properties, each assigned a unique value from 1 to 10,000. This object will be used as the test data for all the benchmark test cases.

**Html Preparation Code**

The html preparation code includes a reference to the Lodash library, which is used in some of the benchmark test cases. Specifically, the `_` variable is an alias for the Lodash object, and `_.values()` is used in two of the test cases.

**Test Cases**

There are six test cases:

1. **For In**: Iterates over the object using the `for...in` loop.
2. **Object values**: Iterates over the object's values using `Object.values()`.
3. **Object keys forEach**: Iterates over the object's keys using `Object.keys()` and then iterates over each key-value pair using `forEach()`.
4. **Object entries forEach**: Iterates over the object's key-value pairs using `Object.entries()` and then iterates over each pair using `forEach()`.
5. **object values forEach** (note: this is a typo, it should be "Object values forEach"): Similar to Test Case 2, but uses `forEach()` to iterate over the values.
6. ** _.forEach(_.values())**: Uses the Lodash library to iterate over the object's values using `_.values()`. This test case is likely included to demonstrate the performance of using a third-party library.

**Library and Special JS Features**

* **Lodash**: A popular utility library for JavaScript that provides various functions for working with arrays, objects, and other data structures. In this benchmark, Lodash is used to implement `_.values()` and `_`.
* **Special JS Feature:** None mentioned in the provided code snippet.

**Pros and Cons of Each Approach**

1. **For In**: Pros: Simple and easy to understand, but can be slower than other approaches due to the need to iterate over the object's properties. Cons: May not be as efficient as other approaches.
2. **Object values**: Pros: Fast and efficient, using `Object.values()` is a modern way to access an object's values. Cons: Requires support for modern JavaScript features (ES6+).
3. **Object keys forEach**: Pros: Similar to Object values, but uses `forEach()` to iterate over the keys. Cons: May be slower than `Object.values()`.
4. **Object entries forEach**: Pros: Fast and efficient, using `Object.entries()` is a modern way to access an object's key-value pairs. Cons: Requires support for modern JavaScript features (ES6+).
5. **object values forEach** (typo): Similar to Object values.
6. ** _.forEach(_.values())**: Pros: Demonstrates the performance of using a third-party library, but may be slower than other approaches due to the overhead of the Lodash library.

**Other Alternatives**

* Using `for...in` and manual iteration over the object's properties
* Using `Array.prototype.forEach()` or `Array.prototype.map()` to iterate over the object's values
* Using `Object.keys()`, `Object.values()`, or `Object.entries()` in combination with `forEach()` or `map()`

Latest run results:

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

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

Browser/OS: Chrome 124 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
For In	36.9 Ops/sec
Object values	37.6 Ops/sec
Object keys forEach	41.8 Ops/sec
Object entries forEach	33.8 Ops/sec
object values forEach	42.4 Ops/sec
_.forEach(_.values())	36.4 Ops/sec

Related benchmarks:

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

Comparing performance of: For In vs Object values vs Object keys forEach vs Object entries forEach vs object values forEach vs _.forEach(_.values())

Created: 6 months ago by: Guest

Jump to the latest result

For In

Object values

Object keys forEach

Object entries forEach

object values forEach

_.forEach(_.values())

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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