Benchmark: lodash map vs Object.keys map vs Object.values

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/lodash/4.16.0/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)
Object.values
Object.values(value)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash.map
native
Object.values

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested, compared, and their pros and cons.

**Benchmark Overview**

The test compares three approaches:

1. `_.map` (Lodash)
2. `Object.keys.map` (Native JavaScript)
3. `Object.values` (Native JavaScript)

All tests use a predefined value object (`value`) that contains multiple properties with different values.

**Library: Lodash**

Lodash is a popular JavaScript utility library that provides a wide range of functions for various tasks, such as array manipulation, string processing, and more. In this benchmark, `_.map` is used to create a new array by applying a transformation function to each element of the original value object.

**Native JavaScript Options**

The two native JavaScript options are:

1. **`Object.keys.map`**: This option uses the `map()` method on an array created from `Object.keys()`, which returns an array of property names from the `value` object.
2. **`Object.values`**: This option directly accesses the values of the `value` object using `Object.values()`.

**Pros and Cons**

Here are some pros and cons for each approach:

* **_.map (Lodash)**:
	+ Pros: Convenient and readable syntax, handles nested objects out of the box.
	+ Cons: Requires Lodash library, which may introduce additional overhead.
* **`Object.keys.map` (Native JavaScript)**:
	+ Pros: Faster than `_.map`, as it avoids the overhead of a function call.
	+ Cons: More verbose and less readable syntax, requires manual handling of nested objects.
* **`Object.values` (Native JavaScript)**:
	+ Pros: Fastest option, as it directly accesses the values without any additional processing.
	+ Cons: Only works for simple objects with no nested properties; can be slower than `_.map` due to object lookup.

**Other Considerations**

When evaluating these options, consider the following:

* If you need a more concise and readable syntax, `.map` (Lodash) might be a better choice.
* If you're working with large datasets or performance-critical code, `Object.values` might be the best option.
* If you need to handle nested objects, either approach can work, but `_.map` is often a more convenient and readable solution.

**Alternatives**

If you don't want to use Lodash, you could also consider using other utility libraries like:

* ES6's built-in array methods (`map()`, `forEach()`)
* Other JavaScript libraries like Underscore.js or Ramda

Alternatively, if you prefer not to use a library at all, you can implement the same functionality manually using `forEach()` or `for...of` loops.

Keep in mind that this benchmark is specific to comparing these three options on Chrome 96 running on macOS. Results may vary across different browsers, platforms, and versions.

Latest run results:

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

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

Browser/OS: Chrome 96 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
lodash.map	6002649.0 Ops/sec
native	7339158.0 Ops/sec
Object.values	7813067.0 Ops/sec

Related benchmarks:

lodash map vs Object.keys map vs Object.values (version: 0)

lodash map vs Object.keys map vs Object.values

Comparing performance of: lodash.map vs native vs Object.values

Created: 2 years ago by: Guest

Jump to the latest result

lodash.map

native

Object.values

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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