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

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
_.each(obj, function(v, k) {})
lodash.map
_.map(obj, function(v, k) {})
Object.entries.map
Object.entries(obj).map(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]; }
lodash.forEach
_.forEach(obj, function(v, k) {})
Object.values
const entries = Object.values(obj); for (let i = 0; i < entries.length; i++) { const v = entries[i]; }
Object.keys
const entries = Object.keys(obj); for (let i = 0; i < entries.length; i++) { const [k, v] = entries[i]; }

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
Object.keys

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the details of what's being tested in this benchmark.

**Benchmark Overview**

The benchmark compares the performance of four ways to iterate over an object: Lodash's `each`, `map`, and `forEach` functions, as well as three vanilla JavaScript approaches using `Object.entries`, `Object.keys`, and a custom for-loop with `Object.entries`. The test case uses a large array-like object created from 10,000 elements.

**Options Compared**

The benchmark compares the following options:

1. **Lodash's each**: Uses Lodash's `_each` function to iterate over the object.
2. **Vanilla Object.entries**: Iterates directly over the `entries` property of the object using a for-loop.
3. **Object.keys**: Iterates over the `keys` property of the object, which returns an array-like object containing the keys as strings. This approach requires additional work to access the values.
4. **Vanilla Object.entries map**: Uses the `map` function on the result of calling `Object.entries`, which creates a new array with transformed entries.
5. **Lodash's map**: Uses Lodash's `_map` function to iterate over the object and create a new array with transformed values.

**Pros and Cons**

Here are some pros and cons for each approach:

1. **Lodash's each**:
	* Pros: Convenient, easy to use, and well-tested.
	* Cons: Additional dependency on Lodash, may not be as efficient due to overhead.
2. **Vanilla Object.entries**:
	* Pros: No additional dependencies, simple implementation.
	* Cons: Requires manual iteration and indexing, can be slower due to the need for explicit loop control.
3. **Object.keys**:
	* Pros: Can be faster than `Object.entries` if the keys are small strings, as lookups are more efficient in this case.
	* Cons: Requires additional work to access values, may not be suitable for large objects with many properties.
4. **Vanilla Object.entries map**:
	* Pros: Convenient and expressive syntax, no additional dependencies required.
	* Cons: Creates a new array with transformed entries, which can be memory-intensive for large objects.
5. **Lodash's map**:
	* Pros: Convenience and expressiveness, similar to `Object.entries map`, but without the need to create an intermediate result.
	* Cons: Additional dependency on Lodash, may not be as efficient due to overhead.

**Library Use**

The benchmark uses Lodash version 4.17.5 for its functions (`each`, `map`, and `forEach`).

**Special JS Features or Syntax**

None of the test cases use any special JavaScript features or syntax that would affect their performance in a significant way. The focus is on comparing the basic iteration approaches.

**Alternatives**

Other alternatives to these approaches include:

* Using `for...of` loops, which can be more concise and expressive than traditional for-loops.
* Utilizing libraries like Ramda or Underscore.js, which provide functional programming utilities that can simplify certain types of iteration.
* Leveraging native JavaScript features like `Promise.all()` or `reduce()`, which can offer performance benefits in specific scenarios.

Keep in mind that the choice of approach often depends on the specific requirements and constraints of a particular use case.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36

Browser/OS: Chrome 127 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
lodash.each	8325.2 Ops/sec
lodash.map	8214.4 Ops/sec
Object.entries.map	3785.1 Ops/sec
vanilla for-loop w/ Object.entries	4630.8 Ops/sec
lodash.forEach	8308.6 Ops/sec
Object.values	52363.0 Ops/sec
Object.keys	6713.9 Ops/sec

Related benchmarks:

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

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 vs Object.keys

Created: 2 years ago by: Guest

Jump to the latest result

lodash.each

lodash.map

Object.entries.map

vanilla for-loop w/ Object.entries

lodash.forEach

Object.values

Object.keys

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