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

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

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

Browser/OS: Chrome 106 on Linux

View result in a separate tab

Test name	Executions per second
lodash.each	447.7 Ops/sec
lodash.map	447.6 Ops/sec
Object.entries.map	238.8 Ops/sec
vanilla for-loop w/ Object.entries	332.3 Ops/sec
lodash.forEach	454.0 Ops/sec
Object.values for	396.1 Ops/sec
Object.keys for	861.4 Ops/sec
Object.keys for in	694.0 Ops/sec
Object.values for of	369.4 Ops/sec
Object.keys for of	471.2 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 2 months 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:

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: 2 years ago by: Registered User

Jump to the latest 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

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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