Benchmark: ES6 equivalent to lodash _.mapValues

HTML Preparation code:

<script src="https://raw.githubusercontent.com/lodash/lodash/4.17.15-npm/core.js"></script>

Tests:

native approach with reduce
var fruits= { 'apple': { 'name': 'apple', 'number': 5}, 'orange': { 'name': 'orange', 'number': 10 } }; console.log(Object.entries(fruits) .reduce((a, [key, { number }]) => { a[key] = number; return a; }, {} ));
native approach fromEntries
var fruits= { 'apple': { 'name': 'apple', 'number': 5}, 'orange': { 'name': 'orange', 'number': 10 } }; console.log(Object.fromEntries( Object.entries(fruits).map(([key, { number }]) => [key, number]) ));
lodash mapValues
var fruits= { 'apple': { 'name': 'apple', 'number': 5}, 'orange': { 'name': 'orange', 'number': 10 } }; _.mapValues(fruits, 'number');

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
native approach with reduce
native approach fromEntries
lodash mapValues

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 world of JavaScript benchmarks!

The provided JSON represents a benchmark for measuring the performance of three different approaches to transform an object with nested values:

1. **ES6 equivalent to lodash _.mapValues**: This approach uses the `_.mapValues` method from the Lodash library, which is a utility library for functional programming tasks.
2. **Native approach with reduce**: This approach uses the `reduce` method built into JavaScript's Array prototype, which is a powerful function that can be used to perform a variety of operations on arrays or objects.
3. **Native approach fromEntries**: This approach uses the `Object.fromEntries` and `Array.prototype.map` methods, which are also native JavaScript functions.

Now, let's break down each approach:

**ES6 equivalent to lodash _.mapValues**

* Pros:
	+ Easy to read and understand
	+ Uses a familiar Lodash method, making it easier for developers who are already familiar with the library
* Cons:
	+ Requires an external dependency (Lodash), which may add overhead to the benchmark
	+ May not be as performant as native approaches due to the added abstraction layer

**Native approach with reduce**

* Pros:
	+ Highly optimized and efficient, as it leverages the built-in `reduce` method
	+ No external dependencies or overhead
* Cons:
	+ Requires a good understanding of the `reduce` method and its behavior
	+ May be less readable than other approaches

**Native approach fromEntries**

* Pros:
	+ Easy to read and understand, as it uses familiar JavaScript methods
	+ Does not require any external dependencies or overhead
* Cons:
	+ May have slightly worse performance compared to the `reduce` method due to the added function calls

Now, let's talk about the library used in the benchmark:

**Lodash**

Lodash is a utility library for functional programming tasks. It provides a wide range of functions and methods that can be used to simplify code and improve performance. In this case, the `_mapValues` method is used to transform an object with nested values.

The Lodash library is widely used in the JavaScript community, but it does add overhead due to its dependency on external libraries (e.g., DOM manipulation and string manipulation functions). However, for many use cases, the benefits of using Lodash outweigh the costs.

As for special JS features or syntax:

* There is no explicit mention of any special features or syntax in the benchmark. The code uses standard JavaScript syntax and does not rely on any esoteric features like async/await, decorators, or type annotations.
* However, it's worth noting that some browsers may optimize certain types of code (e.g., function calls) differently due to their internal execution engines.

Now, let's talk about alternative approaches:

**Other alternatives**

There are several other approaches that could be used to transform an object with nested values. Some examples include:

* Using a library like `ramda` or `underscore`, which provide similar functionality to Lodash
* Implementing the transformation manually using loops and conditional statements
* Using a functional programming library like `fablejs` or `mobx`
* Using a template engine like Handlebars or Mustache to generate the transformed output

However, these alternatives may not be as performant or efficient as the native approaches used in this benchmark.

In summary, the benchmark measures the performance of three different approaches to transform an object with nested values. The ES6 equivalent to lodash _.mapValues approach uses a familiar Lodash method, while the native approaches use built-in JavaScript methods. Each approach has its pros and cons, and the choice of which one to use will depend on the specific requirements of the project.

Latest run results:

Run details: (Test run date: 5 days ago)

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

Browser/OS: Firefox 132 on Windows

View result in a separate tab

Test name	Executions per second
native approach with reduce	88883.8 Ops/sec
native approach fromEntries	81802.3 Ops/sec
lodash mapValues	3100463.5 Ops/sec

Related benchmarks:

ES6 equivalent to lodash _.mapValues (version: 0)

Comparing performance of: native approach with reduce vs native approach fromEntries vs lodash mapValues

Created: 4 years ago by: Guest

Jump to the latest result

native approach with reduce

native approach fromEntries

lodash mapValues

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