Benchmark: Loop over object: lodash vs Object.entries vs Object.keys vs Object.values vs for of vs for in vs keys for of

Loop over object: lodash vs Object.entries vs Object.keys vs Object.values vs for of vs for in vs keys for of (version: 1)

Comparing performance of: lodash.each vs lodash.map vs Object.entries.map vs vanilla for-loop w/ Object.entries vs lodash.forEach vs Object.values for vs Object.keys for vs Object.keys for in vs Object.values for of vs Object.keys for of

Created: 3 years ago by: Registered User

Jump to the latest result

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[`key ${v}`] = `val ${v}`; 
	return val; }, {})

Tests:

lodash.each
_.each(obj, function(v, k) { const res = obj[k]; })
lodash.map
_.map(obj, function(v, k) { const res = obj[k]; })
Object.entries.map
Object.entries(obj).map(function([k, v]) { const res = obj[k]; })
vanilla for-loop w/ Object.entries
const entries = Object.entries(obj); for (let i = 0; i < entries.length; i++) { const [k, v] = entries[i]; }
lodash.forEach
_.forEach(obj, function(v, k) { const res = obj[k]; })
Object.values for
const entries = Object.values(obj); for (let i = 0; i < entries.length; i++) { const v = entries[i]; }
Object.keys for
const entries = Object.keys(obj); for (let i = 0; i < entries.length; i++) { const [k, v] = entries[i]; }
Object.keys for in
const entries = Object.keys(obj); for (const key in entries) { const [k, v] = entries[key];}
Object.values for of
const entries = Object.values(obj); for (const value of entries) {const v = value;}
Object.keys for of
const entries = Object.keys(obj); for (const key of entries) { const v = obj[key]; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash.each
lodash.map
Object.entries.map
vanilla for-loop w/ Object.entries
lodash.forEach
Object.values for
Object.keys for
Object.keys for in
Object.values for of
Object.keys for of

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

**Overview of the Benchmark**

The provided benchmark measures the performance of different approaches to iterate over an object in JavaScript:

* `lodash.forEach`, `lodash.each`
* Vanilla `for` loops with `Object.entries`, `Object.values`, and their corresponding methods (`Object.keys`, `Object.keys for in`)
* Vanilla `for...of` loops with `Object.entries` and `Object.values`

**Options Compared**

The benchmark compares the performance of these different approaches:

1. Lodash functions (`lodash.forEach` and `lodash.each`)
2. Vanilla `for` loops with object iteration methods (`Object.entries`, `Object.values`, and their corresponding methods)
3. Vanilla `for...of` loops with object iteration methods

**Pros and Cons**

Here's a brief summary of the pros and cons of each approach:

1. **Lodash functions**:
	* Pros: Easy to use, concise code, well-tested and maintainable.
	* Cons: External dependency (Lodash library), potentially slower due to function overhead.
2. **Vanilla `for` loops with object iteration methods**:
	* Pros: Fast, lightweight, and easy to understand.
	* Cons: More verbose code, may require more manual error handling.
3. **Vanilla `for...of` loops with object iteration methods**:
	* Pros: Similar to vanilla `for` loops, but with a modern twist (more concise).
	* Cons: May not be as widely supported in older browsers.

**Performance**

The benchmark results show that:

1. Vanilla `for` loops with object iteration methods are generally the fastest.
2. Lodash functions are slower than vanilla `for` loops, but still relatively fast.
3. Vanilla `for...of` loops with object iteration methods are similar to vanilla `for` loops in terms of performance.

**Recommendations**

Based on these results, if you need to iterate over an object in a performance-critical section of code:

* Use vanilla `for` loops with object iteration methods (e.g., `Object.entries`, `Object.values`) for maximum speed.
* Consider using Lodash functions if ease of use and concise code are more important than raw speed.

If you're working with older browsers or need to support them, consider using vanilla `for...of` loops with object iteration methods for a balance between performance and compatibility.

Related benchmarks: