Benchmark: Lodash object mapping vs native mapping with Obect.entries

HTML Preparation code:

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

Tests:

Object.entries and Array.map
const stats = { size: 5, age: 37, length: 10 }; const result = Object.fromEntries( Object.entries(stats).map(([key, value]) => [key, value * 3]) );
Lodash map
const stats = { size: 5, age: 37, length: 10 }; const result = _.mapValues(stats, (val) => val * 3);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.entries and Array.map
Lodash map

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the JavaScript microbenchmarking world of MeasureThat.net.

**Overview**

The benchmark provided compares two approaches to perform object mapping: using Lodash's `mapValues` method versus using native `Object.entries` and `Array.map`. The test is designed to measure the performance difference between these two methods in a JavaScript engine.

**Options Compared**

Two options are compared:

1. **Lodash's `mapValues` method**: This method is part of the Lodash library, which provides a utility function for mapping values in an object.
2. **Native `Object.entries` and `Array.map` combination**: This approach uses the `Object.entries` method to extract key-value pairs from an object, maps over the resulting array using `Array.map`, and then creates a new object with the transformed key-value pairs.

**Pros and Cons**

**Lodash's `mapValues` method:**

Pros:

* Provides a concise and readable way to perform object mapping.
* Often results in more efficient code due to optimizations implemented by Lodash.

Cons:

* Introduces an external dependency on the Lodash library, which may not be desirable for every project.
* May incur additional overhead due to the library's initialization and garbage collection requirements.

**Native `Object.entries` and `Array.map` combination:**

Pros:

* Does not introduce any external dependencies.
* Can result in more efficient code if implemented carefully, as it avoids the overhead of a library function call.

Cons:

* Requires a deeper understanding of JavaScript object iteration and array manipulation techniques.
* May be less readable or maintainable for some developers due to its explicit nature.

**Library Used**

Lodash is a popular JavaScript utility library that provides a wide range of functions for tasks such as array manipulation, object transformation, and more. In this benchmark, Lodash's `mapValues` method is used to perform the object mapping.

**Special JS Feature or Syntax**

None are mentioned in the provided code snippets, so we can assume they are standard JavaScript features.

**Other Alternatives**

If you're looking for alternative libraries or approaches for performing object mapping, consider:

* Using a different utility library, such as Ramda or Immutable.js.
* Implementing your own object mapping function using `Object.keys()`, `Array.prototype.forEach()`, and other basic JavaScript techniques.
* Leveraging modern JavaScript features like template literals, spread operators, or destructuring to simplify object manipulation.

For the specific problem of comparing object mapping performance, you may also consider using a benchmarking library like Benchmark.js or Microbenchmark to create more comprehensive benchmarks.

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/89.0.4389.114 Safari/537.36

Browser/OS: Chrome 89 on Windows

View result in a separate tab

Test name	Executions per second
Object.entries and Array.map	450310.7 Ops/sec
Lodash map	1135384.8 Ops/sec

Related benchmarks:

Lodash object mapping vs native mapping with Obect.entries (version: 0)

Compare the performance of Lodash object map method to using native Object.entries.

Comparing performance of: Object.entries and Array.map vs Lodash map

Created: 4 years ago by: Guest

Jump to the latest result

Object.entries and Array.map

Lodash map

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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