Benchmark: Loop over object: lodash vs Object.entries and Object.keys

HTML Preparation code:

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

AخA
 
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.15/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; }, {})

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

Tests:

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

for in

for (const k in obj) {
  const v = obj[k]
}

 
for (const k in obj) {  const v = obj[k]}

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

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

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/98.0.4758.80 Safari/537.36 Edg/98.0.1108.50

Browser/OS: Chrome 98 on Windows

View result in a separate tab

Test name	Executions per second
lodash.each	3082.9 Ops/sec
lodash.map	3103.2 Ops/sec
Object.entries.forEach	1506.1 Ops/sec
vanilla for-loop w/ Object.entries	1842.7 Ops/sec
Object.keys.forEach	848.2 Ops/sec
vanilla for-loop w/ Object.keys	917.2 Ops/sec
for in	828.9 Ops/sec

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

The provided JSON represents a benchmarking test for comparing the performance of different approaches to iterate over an object in JavaScript.

Here's what's being tested:

Lodash methods: The benchmark compares the performance of two Lodash methods: _.each and _.map. Both methods are used to iterate over an array (in this case, an object) and perform some operation on each element.
Vanilla Object iteration: Two approaches are tested using vanilla JavaScript:
- Object.entries.forEach: This method iterates over the key-value pairs of an object using the entries() method and then executes a callback function for each pair.
- vanilla for-loop w/ Object.keys : This approach uses a traditional for loop with the Object.keys() method to get an array of the object's keys, and then iterates over that array to access the corresponding values in the object.

The pros and cons of these approaches are:

Lodash methods:

Pros:

These methods are concise and easy to read.
They handle the iteration and execution of callbacks internally, which can be beneficial for performance.

Cons:

Adding extra dependencies (in this case, Lodash) may increase the size of the bundle and potentially impact loading times.
The performance benefits may not outweigh the added overhead of the dependency.

Vanilla Object iteration:

Pros:

These methods are pure JavaScript and don't require any external libraries or dependencies.
They can be more efficient for small to medium-sized datasets, as they avoid the overhead of a JavaScript runtime.

Cons:

These methods can be less readable and more verbose than their Lodash counterparts.
The performance benefits may decrease as the dataset size increases, due to the additional overhead of manually managing iteration.

For-in loop:

Pros:

This method is often considered one of the most efficient ways to iterate over an object in JavaScript, especially for larger datasets.
It doesn't require any external libraries or dependencies.

Cons:

This method can be less readable and more verbose than other approaches.
The performance benefits may come at the cost of slightly slower execution times due to the additional overhead of using a traditional loop.

Other considerations:

The benchmark results show that the Chrome 98 browser performed consistently well across all tests, with minor variations in execution speed.
The "ExecutionsPerSecond" metric provides an indication of each test's performance relative to others. For example, Object.entries.forEach and for-in were generally faster than Lodash methods.

Alternatives:

Other approaches for iterating over objects might include:
- Using forEach() on the object itself (e.g., obj.forEach())
- Utilizing iterators or generators
- Leveraging modern JavaScript features like for...of loops

LLMs can make mistakes. Check important info.

The provided JSON represents a benchmarking test for comparing the performance of different approaches to iterate over an object in JavaScript.

Here's what's being tested:

1. **Lodash methods**: The benchmark compares the performance of two Lodash methods: `_.each` and `_.map`. Both methods are used to iterate over an array (in this case, an object) and perform some operation on each element.
2. **Vanilla Object iteration**: Two approaches are tested using vanilla JavaScript:
	* `Object.entries.forEach`: This method iterates over the key-value pairs of an object using the `entries()` method and then executes a callback function for each pair.
	* `vanilla for-loop w/ Object.keys` : This approach uses a traditional for loop with the `Object.keys()` method to get an array of the object's keys, and then iterates over that array to access the corresponding values in the object.

The pros and cons of these approaches are:

**Lodash methods:**

Pros:

* These methods are concise and easy to read.
* They handle the iteration and execution of callbacks internally, which can be beneficial for performance.

Cons:

* Adding extra dependencies (in this case, Lodash) may increase the size of the bundle and potentially impact loading times.
* The performance benefits may not outweigh the added overhead of the dependency.

**Vanilla Object iteration:**

Pros:

* These methods are pure JavaScript and don't require any external libraries or dependencies.
* They can be more efficient for small to medium-sized datasets, as they avoid the overhead of a JavaScript runtime.

Cons:

* These methods can be less readable and more verbose than their Lodash counterparts.
* The performance benefits may decrease as the dataset size increases, due to the additional overhead of manually managing iteration.

**For-in loop:**

Pros:

* This method is often considered one of the most efficient ways to iterate over an object in JavaScript, especially for larger datasets.
* It doesn't require any external libraries or dependencies.

Cons:

* This method can be less readable and more verbose than other approaches.
* The performance benefits may come at the cost of slightly slower execution times due to the additional overhead of using a traditional loop.

Other considerations:

* The benchmark results show that the Chrome 98 browser performed consistently well across all tests, with minor variations in execution speed.
* The "ExecutionsPerSecond" metric provides an indication of each test's performance relative to others. For example, `Object.entries.forEach` and `for-in` were generally faster than Lodash methods.

Alternatives:

* Other approaches for iterating over objects might include:
	+ Using `forEach()` on the object itself (e.g., `obj.forEach()`)
	+ Utilizing iterators or generators
	+ Leveraging modern JavaScript features like `for...of` loops

Related benchmarks:

Loop over object: lodash vs Object.entries and Object.keys (version: 0)

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

Created: 3 years ago by: Guest

Jump to the latest result

lodash.each

lodash.map

Object.entries.forEach

vanilla for-loop w/ Object.entries

Object.keys.forEach

vanilla for-loop w/ Object.keys

for in

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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