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

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:140.0) Gecko/20100101 Firefox/140.0

Browser/OS: Firefox 140 on Mac OS X 10.15

View result in a separate tab

Test name	Executions per second
lodash.each	9239.9 Ops/sec
lodash.map	5936.7 Ops/sec
Object.entries.map	4264.0 Ops/sec
vanilla for-loop w/ Object.entries	5148.2 Ops/sec

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

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

Fastest: N/A

Slowest: N/A

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