Benchmark: lodash.mapKeys vs Iterating over Object.keys

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.mapKeys
_.mapKeys(value, k => k + '-changed')
native
Object.assign({}, ...Object.keys(value).map(k => ({ [k + '-changed']: value[k] })))

Historical Performance Data aggregated from 7 community runs

Desktop Results:

Chrome 7 runs

lodash.mapKeys

2.7M/s

native

972K/s

Fastest: lodash.mapKeys (2.7x faster)

View exact numbers

✓ lodash.mapKeys: 2,650,504 ops/sec
• native: 972,362 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash.mapKeys
native

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36

Browser/OS: Chrome 149 on Linux

View result in a separate tab

lodash.mapKeys

1.8M/s

native

944K/s

View exact numbers

Test name	Executions per second
✓ lodash.mapKeys	1,811,586 Ops/sec
native	943,926 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the benchmark definition and options being compared.

**Benchmark Definition:**

The benchmark is comparing two approaches to iterate over an object and create a new object with modified key-value pairs:

1. **Lodash `_.mapKeys`**: This function takes an object, a callback function, and returns a new object with the same keys but modified according to the callback.
2. **Native JavaScript iteration**: This approach uses `Object.keys()` to get an array of keys from the original object, maps over it using `Array.prototype.map()`, creates a new object using `Object.assign()`, and updates each key-value pair.

**Options being compared:**

* Lodash `_.mapKeys`
* Native JavaScript iteration

**Pros and Cons of each approach:**

1. **Lodash `_.mapKeys`**:
	* Pros:
		+ More concise and readable code
		+ Less prone to errors due to the callback function providing a clear contract for modification
	* Cons:
		+ Requires an additional library (Lodash)
		+ May have performance overhead due to the creation of a new function object on each execution
2. **Native JavaScript iteration**:
	* Pros:
		+ No external libraries required
		+ Can be optimized for performance by using native functions and caching intermediate results
	* Cons:
		+ More verbose code, potentially leading to errors due to complex logic
		+ May require more manual bookkeeping (e.g., managing the array of keys)

**Library: Lodash**

Lodash is a popular JavaScript utility library that provides a wide range of functions for tasks such as data manipulation, object creation, and more. In this benchmark, `_.mapKeys` is used to create a new object with modified key-value pairs.

**Special JS feature or syntax: None mentioned**

The benchmark does not use any special JavaScript features or syntax, so there's no need to explain anything in that regard.

**Other alternatives**

If you're interested in exploring alternative approaches, some options could include:

* Using `Object.entries()` and `Array.prototype.reduce()` for a more concise solution
* Implementing your own custom mapping function using recursion or iteration
* Utilizing other libraries like `ramda` or `functional-programming` frameworks

Keep in mind that each alternative approach will have its pros and cons, and the best choice depends on the specific requirements of your project.

In terms of benchmark results, the provided data shows:

* Firefox 124 with an execution rate of approximately 4.79 million iterations per second for Lodash `_.mapKeys`
* Firefox 124 with an execution rate of approximately 2.78 million iterations per second for native JavaScript iteration

These results suggest that Lodash `_.mapKeys` is currently performing better than the native JavaScript iteration approach in this benchmark, but keep in mind that performance can vary depending on the specific use case and environment.

lodash.mapKeys vs Iterating over Object.keys (version: 0) Benchmark.js

Comparing performance of: `lodash.mapKeys vs native`

Created: 8 years ago by: Guest

Go to the latest result

lodash.mapKeys

native

Historical Performance Data aggregated from 7 community runs

Desktop Results:

Chrome 7 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

lodash.mapKeys vs Iterating over Object.keys (version: 0) Benchmark.js

Comparing performance of: lodash.mapKeys vs native

Created: 8 years ago by: Guest

Go to the latest result

lodash.mapKeys

native

Historical Performance Data aggregated from 7 community runs

Desktop Results:

Chrome 7 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `lodash.mapKeys vs native`