Benchmark: lodash foreach vs for-of vs forEach

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js"></script>

Script Preparation code:

var obj = Array.from({ length: 10000 }).map((value, i) => i).reduce((val, v) => { val[v] = v; return val; }, {})

Tests:

lodash.foreach
_.forEach(obj, function(v,k) {})
native for-of w/ entries
for (const [k, v] of Object.entries(obj)) {}
native forEach w/ entries
Object.entries(obj).forEach(function(v, k) {})
vanilla for-loop w/ Object.keys
const keys = Object.keys(obj); for (let i = 0; i < keys.length; i++) { const v = obj[keys[i]]; }
vanilla for-loop w/ Object.entries
const entries = Object.entries(obj); for (let i = 0; i < entries.length; i++) { const [k, v] = entries[i]; }
vanilla for-loop w/ Object.values (no keys)
const values = Object.values(obj); for (let i = 0; i < values.length; i++){ }
native forEach w/ Object.values (no keys)
Object.values(obj).forEach(function(v) {})
native for-in
for (const prop in obj) { if (obj.hasOwnProperty(prop)) { const v = obj[prop]; } }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash.foreach
native for-of w/ entries
native forEach w/ entries
vanilla for-loop w/ Object.keys
vanilla for-loop w/ Object.entries
vanilla for-loop w/ Object.values (no keys)
native forEach w/ Object.values (no keys)
native for-in

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 benchmark and explain what is being tested.

**Benchmark Overview**

The benchmark compares the performance of four different approaches to iterate over an object in JavaScript:

1. `lodash.foreach`
2. `native for-of w/ entries` (using `for...of` loop with `Object.entries()`)
3. `native forEach w/ entries` (using `forEach()` method with `Object.entries()`)
4. `vanilla for-loop w/ Object.values` (using `for...of` loop with `Object.values()`)
5. `vanilla for-loop w/ Object.keys` (using `for...of` loop with `Object.keys()`)
6. `vanilla for-loop w/ Object.entries` (using `for...of` loop with `Object.entries()`)
7. `vanilla for-loop w/ Object.values (no keys)` (using `for...of` loop with `Object.values()` without accessing keys)
8. `native for-in`

**Options Compared**

The benchmark compares the performance of each approach against others, but not directly between all options. Instead, it's more like a tiered comparison:

* The first two options (`native for-of w/ entries` and `native forEach w/ entries`) are compared to each other.
* The next three options (`vanilla for-loop w/ Object.values`, `vanilla for-loop w/ Object.keys`, and `vanilla for-loop w/ Object.entries`) are compared to each other, with the `native for-in` option as a baseline.

**Pros and Cons of Each Approach**

Here's a brief summary:

* **`lodash.foreach`**: Uses the Lodash library, which provides a convenient way to iterate over objects. However, this approach comes at a performance cost due to the overhead of the library.
* **`native for-of w/ entries`**: A modern JavaScript feature that allows iterating over arrays and objects using `for...of`. This approach is concise and efficient but requires support for ES6+ syntax.
* **`native forEach w/ entries`**: Another way to iterate over arrays and objects using the `forEach()` method with `Object.entries()`. This approach is similar to `native for-of w/ entries`, but uses a different syntax.
* **`vanilla for-loop w/ Object.values`**: Uses a traditional `for...of` loop with `Object.values()`, which can be slower than other approaches due to the overhead of accessing object values without keys.
* **`vanilla for-loop w/ Object.keys`**: Similar to `vanilla for-loop w/ Object.values`, but uses `Object.keys()` instead. This approach has similar performance characteristics as `vanilla for-loop w/ Object.values`.
* **`vanilla for-loop w/ Object.entries`**: Uses a traditional `for...of` loop with `Object.entries()`, which can be slower than other approaches due to the overhead of accessing object entries.
* **`vanilla for-loop w/ Object.values (no keys)`**: A variant of `vanilla for-loop w/ Object.values` that doesn't access object keys, potentially reducing performance overhead.
* **`native for-in`**: An older JavaScript feature that allows iterating over objects using the `in` operator. This approach is slower and less efficient than other options.

**Conclusion**

The benchmark highlights the trade-offs between different iteration approaches in JavaScript. The modern `native for-of w/ entries` and `native forEach w/ entries` options are generally the most efficient, while the `vanilla for-loop w/ Object.values`, `vanilla for-loop w/ Object.keys`, and `vanilla for-loop w/ Object.entries` options can be slower due to their inherent complexity. The `lodash.foreach` option comes at a performance cost due to library overhead.

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36

Browser/OS: Chrome 119 on Linux

View result in a separate tab

Test name	Executions per second
lodash.foreach	6816.3 Ops/sec
native for-of w/ entries	3557.4 Ops/sec
native forEach w/ entries	3683.6 Ops/sec
vanilla for-loop w/ Object.keys	2197.3 Ops/sec
vanilla for-loop w/ Object.entries	3601.5 Ops/sec
vanilla for-loop w/ Object.values (no keys)	60806.4 Ops/sec
native forEach w/ Object.values (no keys)	60168.8 Ops/sec
native for-in	1177.7 Ops/sec

Related benchmarks:

lodash foreach vs for-of vs forEach (version: 0)

Comparing performance of: lodash.foreach vs native for-of w/ entries vs native forEach w/ entries vs vanilla for-loop w/ Object.keys vs vanilla for-loop w/ Object.entries vs vanilla for-loop w/ Object.values (no keys) vs native forEach w/ Object.values (no keys) vs native for-in

Created: 4 years ago by: Guest

Jump to the latest result

lodash.foreach

native for-of w/ entries

native forEach w/ entries

vanilla for-loop w/ Object.keys

vanilla for-loop w/ Object.entries

vanilla for-loop w/ Object.values (no keys)

native forEach w/ Object.values (no keys)

native for-in

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):