Benchmark: Loop over object: lodash vs Object.entries

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]; }

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

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON data and explain what's being tested in each test case.

**Benchmark Definition**

The provided JSON represents a JavaScript microbenchmark, which is a small piece of code designed to measure the performance of specific parts of a larger program.

In this benchmark, four different approaches are compared:

1. **Lodash**: A popular JavaScript library that provides a set of utility functions for tasks like array manipulation, object iteration, and more.
2. **Vanilla JavaScript** (without Lodash): This approach uses only native JavaScript features without the aid of any external libraries.

The goal is to determine which approach is faster in terms of execution time.

**Options Compared**

The two main options being compared are:

1. **Lodash**: Using Lodash functions like `_.each` and `_.map` for array manipulation.
2. **Vanilla JavaScript**: Using native JavaScript features like `for...of` loops with `Object.entries` to iterate over the object.

**Pros and Cons**

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

1. **Lodash**:
	* Pros: Easier to write code, less error-prone, and more readable.
	* Cons: Adds an external dependency (the Lodash library), which may increase overhead due to additional HTTP requests or file loading times.
2. **Vanilla JavaScript**:
	* Pros: No external dependencies, faster execution time due to reduced overhead.
	* Cons: More difficult to write code, and potential for more errors.

**Library**

In this benchmark, the Lodash library is used as a third-party dependency. Lodash provides a set of utility functions that can simplify code and improve performance in certain scenarios. The `_.each` function is used for iterating over an object's values, while the `_.map` function is used for transforming an array.

**Special JS Feature**

There is no special JavaScript feature or syntax being tested in this benchmark. However, the use of `Object.entries` and `for...of` loops with it highlights some interesting aspects of modern JavaScript:

* `Object.entries`: A relatively new feature introduced in ECMAScript 2015 (ES6), which allows iterating over an object's key-value pairs as arrays.
* `for...of` loops: A type of loop that can be used to iterate over arrays, objects, and other iterable values.

**Other Alternatives**

If you were to create a similar benchmark for another approach or library, some alternatives could include:

1. Using different libraries like Ramda, Underscore.js, or Moment.js.
2. Implementing custom solutions using native JavaScript features but without the use of external libraries.
3. Comparing the performance of different loop constructs, such as `for` loops versus `while` loops.

Keep in mind that benchmarking results can vary depending on factors like hardware, software configurations, and test environments, so it's essential to run multiple tests to ensure accurate conclusions.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:131.0) Gecko/20100101 Firefox/131.0

Browser/OS: Firefox 131 on Windows

View result in a separate tab

Test name	Executions per second
lodash.each	5614.1 Ops/sec
lodash.map	3871.1 Ops/sec
Object.entries.map	2847.1 Ops/sec
vanilla for-loop w/ Object.entries	3530.6 Ops/sec

Related benchmarks:

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

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

Created: 5 years ago by: Guest

Jump to the latest result

lodash.each

lodash.map

Object.entries.map

vanilla for-loop w/ Object.entries

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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