Benchmark: lodash vs for-of vs forEach vs map v2

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; }, {});
var arr = [...Array.from(10000).keys()];

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 = arr.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

Latest run results:

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

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

Browser/OS: Chrome 109 on Windows

View result in a separate tab

Test name	Executions per second
lodash.each	1936.6 Ops/sec
native for-of w/ entries	966.7 Ops/sec
native forEach w/ entries	792.0 Ops/sec
vanilla for-loop w/ Object.keys	615.0 Ops/sec
vanilla for-loop w/ Object.entries	992.0 Ops/sec
vanilla for-loop w/ Object.values (no keys)	14435.5 Ops/sec
native forEach w/ Object.values (no keys)	10951.5 Ops/sec
native for-in	472.7 Ops/sec
map	9311743.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down what's being tested in the provided JSON.

**Benchmark Definition**

The benchmark is comparing the performance of different approaches to iterate over an object and push values into an array:

1. `lodash.each`
2. Native `for-of` with `Object.entries`
3. Native `forEach` with `Object.entries`
4. Vanilla `for-loop` with `Object.keys`
5. Vanilla `for-loop` with `Object.entries`
6. Vanilla `for-loop` with `Object.values` (no keys)
7. Native `for-in`

**Options Compared**

The options being compared are the methods to iterate over an object and push values into an array:

* `lodash.each`: A utility function from the Lodash library.
* Native `for-of`: A built-in iteration method that returns an iterator object.
* Native `forEach`: A built-in method that calls a callback function for each value in an iterable.
* Vanilla `for-loop` with `Object.keys`: Using the `keys()` method to get an array of keys, and then iterating over it using a traditional `for` loop.
* Vanilla `for-loop` with `Object.entries`: Using the `entries()` method to get an iterator object for key-value pairs, and then iterating over it using a traditional `for` loop.
* Vanilla `for-loop` with `Object.values`: Using the `values()` method to get an iterator object for values, and then iterating over it using a traditional `for` loop (without keys).

**Performance Comparison**

The benchmark measures the execution time of each approach in terms of the number of executions per second. The results show that:

* Native `for-of` with `Object.entries` is generally the fastest.
* Native `forEach` with `Object.values` (no keys) is also fast, but slightly slower than native `for-of`.
* Vanilla `for-loop` with `Object.keys` and `Object.entries` are slower due to the overhead of using an iterator object or iterating over a keys array.
* Lodash's `each` function is the slowest due to its additional functionality and possibly slower iteration method.

**Conclusion**

The results suggest that native iteration methods (`for-of`, `forEach`) are generally faster than vanilla loop implementations with iterator objects. Using `Object.keys` or `Object.entries` can introduce additional overhead, while Lodash's `each` function is the slowest due to its additional functionality.

Related benchmarks:

lodash vs for-of vs forEach vs map v2 (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 2 months ago):