Benchmark: Transform array to object

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.21/lodash.min.js'></script>

Script Preparation code:

var data = Array.from({length: 1000}, (v, i) => ({ name: `${i + 1}`, value: i + 1}));

var keyBy = (array, fn) => {
    return array.reduce((acc, value) => {
        acc[fn(value)] = value;
        return acc;
    }, {});
};

var keyByUsingSpread = (array, fn) => {
    return array.reduce((acc, value) => {
        return {
            ...acc,
            [fn(value)]: value
        };
    }, {});
};

Tests:

lodash/keyBy
_.keyBy(data, (v) => v.name);
keyBy with native reduce
keyBy(data, (v) => v.name);
keyBy using native reduce and spread operator
keyByUsingSpread(data, (v) => v.name);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash/keyBy
keyBy with native reduce
keyBy using native reduce and spread operator

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

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

**Benchmark Definition**

The benchmark defines two approaches to convert an array to an object using JavaScript:

1. `_.keyBy(data, (v) => v.name)`: This method uses the Lodash library's `keyBy` function, which takes an array and a function as arguments. The function is applied to each element in the array, and the resulting values are used as keys in the output object.
2. `keyBy(data, (v) => v.name)` with native reduce: This method uses the built-in `reduce` function to achieve the same result as the Lodash library's `keyBy` function. It takes an array and a function as arguments, just like the previous approach.
3. `keyByUsingSpread(data, (v) => v.name)` with native reduce and spread operator: This method uses the built-in `reduce` function in combination with the spread operator (`...`) to achieve a similar result to the Lodash library's `keyBy` function.

**Comparison of Approaches**

Here's a brief overview of each approach:

1. **Lodash `keyBy`**: This approach is likely the fastest and most efficient, as it leverages optimized native code within the Lodash library.
	* Pros: High performance, well-optimized, and easy to use.
	* Cons: Requires an additional external dependency (the Lodash library).
2. **Native reduce with function**: This approach uses the built-in `reduce` function to iterate over the array and create a new object with key-value pairs.
	* Pros: No additional dependencies required, uses native code, and can be efficient for simple cases.
	* Cons: May not perform as well as optimized libraries like Lodash for large datasets or complex operations.
3. **Native reduce with spread operator**: This approach combines the built-in `reduce` function with the spread operator (`...`) to create a new object.
	* Pros: No additional dependencies required, uses native code, and can be efficient for simple cases.
	* Cons: Requires understanding of the spread operator's behavior, which might add complexity.

**Library and Syntax Considerations**

The Lodash library is used in the first approach (`_.keyBy(data, (v) => v.name)`). This library provides a wide range of utility functions and optimization techniques, including memoization and caching. The `keyBy` function is specifically designed for converting arrays to objects using a mapping function.

There are no special JavaScript features or syntax used in this benchmark that would require additional explanation.

**Alternative Approaches**

Other possible approaches to convert an array to an object could include:

1. Using the `Object.fromEntries()` method (introduced in ECMAScript 2019) with a callback function.
2. Utilizing the `Array.prototype.reduce()` method without using the spread operator or Lodash library.
3. Leveraging other libraries or frameworks that provide similar functionality, such as Moment.js for date-related conversions.

However, these approaches might not be included in this specific benchmark, and their performance would likely vary depending on the use case and requirements.

**Benchmark Result Interpretation**

The latest benchmark result shows the execution counts per second (ExecutionsPerSecond) for each approach. The results indicate that:

1. `keyBy with native reduce` performs the best, with an average of 50976 executions per second.
2. Lodash `keyBy` is close behind, with an average of 44947 executions per second.
3. `keyBy using native reduce and spread operator` has the lowest performance, with an average of 3541 executions per second.

These results suggest that the optimized approach (Lodash `keyBy`) likely performs better than the native approaches due to its specialized implementation and caching mechanisms.

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/101.0.4951.64 Safari/537.36

Browser/OS: Chrome 101 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
lodash/keyBy	44947.3 Ops/sec
keyBy with native reduce	50976.7 Ops/sec
keyBy using native reduce and spread operator	3541.8 Ops/sec

Related benchmarks:

Transform array to object (version: 3)

Various ways to convert array to objects

Comparing performance of: lodash/keyBy vs keyBy with native reduce vs keyBy using native reduce and spread operator

Created: 2 years ago by: Registered User

Jump to the latest result

lodash/keyBy

keyBy with native reduce

keyBy using native reduce and spread operator

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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