Benchmark: lodash.mapKeys vs Native

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
const f = v => _.mapKeys(v, k => k + '-changed') f(value);
Object.keys with for loop
const f = v => { const m = {}; for (const k of Object.keys(v)) m[k + '-changed'] = v[k]; return m; } f(value)
Object.entries with for loop
const f = obj => { const m = {}; for (const [k, v] of Object.entries(obj)) m[k + '-changed'] = v; return m; } f(value)
Object.keys with reduce
const f = obj => Object.keys(obj).reduce( (acc, k) => ({ ...acc, [k + '-changed']: obj[k] }), {} ); f(value)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash.mapKeys
Object.keys with for loop
Object.entries with for loop
Object.keys with reduce

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Firefox 138 on Windows

View result in a separate tab

Test name	Executions per second
lodash.mapKeys	8350533.0 Ops/sec
Object.keys with for loop	14856037.0 Ops/sec
Object.entries with for loop	11485356.0 Ops/sec
Object.keys with reduce	9321431.0 Ops/sec

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

LLMs can make mistakes. Check important info.

**Overview**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. The provided JSON represents the benchmark definition, which tests different approaches for mapping keys in an object.

**Benchmark Definition**

The benchmark definition is represented by the following JSON:

```json
{
    "Name": "lodash.mapKeys vs Native",
    "Description": null,
    "Script Preparation Code": "var value = {a: 30310, b: 100303, c: 3040494};",
    "Html Preparation Code": "<script src=\"https://cdn.jsdelivr.net/lodash/4.16.0/lodash.min.js\"></script>"
}
```

This code defines an object `value` with three properties: `a`, `b`, and `c`. The script preparation code imports the Lodash library.

**Test Cases**

The benchmark consists of four test cases:

1. **lodash.mapKeys**: This test case uses the `_.mapKeys()` function from Lodash to map keys in the `value` object.
2. **Object.keys with for loop**: This test case uses a traditional for loop to iterate over the properties of the `value` object and create a new object with modified key names.
3. **Object.entries with for loop**: This test case uses the `Object.entries()` function to get an array of key-value pairs from the `value` object, then iterates over this array using a traditional for loop to create a new object with modified key names.
4. **Object.keys with reduce**: This test case uses the `Object.keys()` function to get an array of property names from the `value` object, then applies the `reduce()` method to create a new object with modified key names.

**Comparison**

The test cases compare the performance of using Lodash's `_.mapKeys()` function versus implementing a manual approach using traditional loops (for, for...of) or other methods like `Object.keys()` and `reduce()`. The comparison aims to determine which approach is faster and more efficient.

**Pros and Cons**

* **Lodash's _.mapKeys()**: Pros:
	+ Easy to use and concise syntax.
	+ Built-in implementation in the Lodash library.
* Cons:
	+ May introduce overhead due to the extra function call.
	+ Limited control over the mapping process.
* **Traditional loops (for, for...of)**: Pros:
	+ More control over the mapping process.
	+ No additional function call overhead.
* Cons:
	+ More verbose syntax.
	+ Requires manual iteration and indexing.

**Other Considerations**

* The benchmark uses Safari 17 as the test browser, which may not be representative of all browsers.
* The `value` object is relatively small, so the performance differences between approaches might not be significant for larger objects.

**Library: Lodash**

Lodash is a popular JavaScript library that provides a set of utility functions, including `_.mapKeys()`. It is widely used in the industry and can simplify code by providing a concise and efficient way to perform common operations like mapping keys.

The provided benchmark result shows the performance data for each test case. The top-performing approach will likely be the one with the lowest number of executions per second, indicating better performance efficiency.

Related benchmarks:

lodash.mapKeys vs Native (version: 0)

Comparing performance of: lodash.mapKeys vs Object.keys with for loop vs Object.entries with for loop vs Object.keys with reduce

Created: 5 years ago by: Guest

Jump to the latest result

lodash.mapKeys

Object.keys with for loop

Object.entries with for loop

Object.keys with reduce

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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