Benchmark: lodash v4.17.21 map vs Object.keys map

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/npm/lodash@4.17.21/lodash.min.js"></script>

Script Preparation code:

var value = {a: 30310, b: 100303, c: 3040494};

Tests:

lodash.map
_.map(value, (v) => v)
native
Object.keys(value).map((v) => v)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash.map
native

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 3 years ago)

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

Browser/OS: Chrome 93 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
lodash.map	5743252.0 Ops/sec
native	7168897.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and its details.

**Benchmark Overview**

The benchmark compares the performance of two approaches to map over an object: using the `_.map` function from Lodash (a popular JavaScript utility library) and using the built-in `Object.keys` method with a `map` callback.

**Options Compared**

There are only two options being compared:

1. **Lodash `.map`**: This approach uses the `_.map` function from Lodash to iterate over the object's values.
2. **Native `Object.keys` + `map`**: This approach uses the built-in `Object.keys` method to get an array of the object's keys, and then uses the `map` callback to transform each key into its corresponding value.

**Pros and Cons**

**Lodash `.map`**

Pros:

* Often more concise and readable than using native methods.
* Lodash provides a consistent and predictable API for mapping over objects.

Cons:

* May incur a performance overhead due to the indirection of using a library function.
* Requires including an additional script (in this case, the Lodash library).

**Native `Object.keys` + `map`**

Pros:

* Typically faster than using a library function, as it avoids the overhead of calling a JavaScript function.
* Does not require any additional libraries or scripts.

Cons:

* May be less readable and more verbose than using a library function.
* Requires understanding of native JavaScript methods and their behavior.

**Library: Lodash**

Lodash is a popular JavaScript utility library that provides a wide range of functions for common tasks, such as array manipulation, object transformation, and more. In this benchmark, the `_.map` function is used to transform the values of an object into a new array.

**Special JS Feature or Syntax: None**

There are no special JavaScript features or syntax being tested in this benchmark.

**Benchmark Preparation Code**

The script preparation code defines an object `value` with three properties (a, b, and c) containing some sample data. The HTML preparation code includes the Lodash library via a CDN link.

**Individual Test Cases**

Each test case represents a single iteration of the benchmark. In this case, there are two test cases:

1. **Lodash `.map`**: This test case uses the `_.map` function from Lodash to transform the values of the `value` object into a new array.
2. **Native `Object.keys` + `map`**: This test case uses the built-in `Object.keys` method and a `map` callback to transform the keys of the `value` object into an array of their corresponding values.

**Latest Benchmark Result**

The latest benchmark result shows the execution times for both test cases on a Chrome 93 browser running on a Mac OS X 10.15.7 system. The native `Object.keys` + `map` approach is currently faster than the Lodash `.map` approach, with an execution time of approximately 5743252 executions per second compared to 7168897 executions per second.

**Other Alternatives**

If you were to implement this benchmark yourself, some other alternatives for mapping over objects could include:

* Using a library like Ramda or Liskov's `map`
* Implementing your own custom map function using native JavaScript methods (e.g., `forEach` and the spread operator)
* Using a different data structure, such as an array of objects instead of an object with string keys.

Keep in mind that the performance difference between these approaches may vary depending on specific use cases and implementation details.

Related benchmarks:

lodash v4.17.21 map vs Object.keys map (version: 0)

lodash map vs Object.keys map

Comparing performance of: lodash.map vs native

Created: 3 years ago by: Guest

Jump to the latest result

lodash.map

native

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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