Benchmark: lodash vs for-of vs forEach vs map

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.each
const a = []; _.each(obj, function(v,k) { a.push(v); });
native for-of w/ entries
const a = []; for (const [k, v] of Object.entries(obj)) { a.push(v); }
native forEach w/ entries
const a =[]; Object.entries(obj).forEach(function(v, k) { a.push(v); })
vanilla for-loop w/ Object.keys
const a=[]; const keys = Object.keys(obj); for (let i = 0; i < keys.length; i++) { const v = obj[keys[i]]; a.push(v);}
vanilla for-loop w/ Object.entries
const a=[]; const entries = Object.entries(obj); for (let i = 0; i < entries.length; i++) { const [k, v] = entries[i]; a.push(v);}
vanilla for-loop w/ Object.values (no keys)
const a =[]; const values = Object.values(obj); for (let i = 0; i < values.length; i++){ a.push(values[i]);}
native forEach w/ Object.values (no keys)
const a =[]; Object.values(obj).forEach(function(v) { a.push(v); })
native for-in
const a =[]; for (const prop in obj) { if (obj.hasOwnProperty(prop)) { const v = obj[prop]; a.push(v);} }
map
const results = Array.from(obj).map(x=>x);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash.each
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
map

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Measuring JavaScript performance is crucial to understand how different approaches affect execution speed.

**Benchmark Overview**

The benchmark tests the performance of various loops in JavaScript when iterating over an object's keys, values, or entries. The test case uses the Lodash library for its `each` function. It also includes vanilla JavaScript alternatives without using any external libraries.

**Comparison of Options**

1. **Lodash's `each`**: This is a higher-order function that takes a callback function as an argument and iterates over the object's keys and values.
2. **Vanilla For-Of with Entries**: This approach uses the `for...of` loop with the `Object.entries()` method to iterate over the object's key-value pairs.
3. **Vanilla For-Each with Entries**: Similar to the previous option, but uses the `forEach()` method instead of a traditional `for...of` loop.
4. **Vanilla For-Loop with Object Keys**: This approach uses the `Object.keys()` method to get an array of keys and then iterates over it using a traditional `for` loop.
5. **Vanilla For-Loop with Object Values (no keys)**: Similar to the previous option, but uses the `Object.values()` method to get an array of values directly.
6. **Vanilla For-In**: This approach uses the `for...in` loop with the `hasOwnProperty()` method to iterate over the object's own enumerable properties.

**Performance Comparison**

The benchmark results show that:

* Lodash's `each` is slower than all vanilla JavaScript alternatives, likely due to the overhead of a higher-order function.
* The vanilla For-Of and For-Each approaches are similar in performance, as they both use the same `Object.entries()` method under the hood. However, the For-Of approach is slightly faster.
* The vanilla For-Loop with Object Keys and Values (no keys) methods are slower than the other options, likely due to the additional overhead of getting an array of keys or values using `Object.keys()` or `Object.values()`.
* The Vanilla For-In loop is the slowest option, likely due to its less efficient iteration mechanism.

**Conclusion**

When it comes to iterating over an object's keys, values, or entries in JavaScript, the vanilla For-Of and For-Each approaches are generally faster than using a higher-order function like Lodash's `each`. However, the performance difference is usually negligible unless you're working with very large datasets. Always profile your code and use the most efficient approach for your specific use case.

Latest run results:

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

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

Browser/OS: Chrome 94 on Linux

View result in a separate tab

Test name	Executions per second
lodash.each	2099.4 Ops/sec
native for-of w/ entries	883.5 Ops/sec
native forEach w/ entries	733.3 Ops/sec
vanilla for-loop w/ Object.keys	707.6 Ops/sec
vanilla for-loop w/ Object.entries	890.6 Ops/sec
vanilla for-loop w/ Object.values (no keys)	14568.0 Ops/sec
native forEach w/ Object.values (no keys)	9173.2 Ops/sec
native for-in	378.5 Ops/sec
map	2035207.1 Ops/sec

Related benchmarks:

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

Comparing performance of: lodash.each 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 vs map

Created: 3 years ago by: Guest

Jump to the latest result

lodash.each

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

map

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