Benchmark: lodash/keyBy vs native reduce

HTML Preparation code:

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

Script Preparation code:

var data = [
  { name: 'pi', value: 3.14 },
  { name: 'hundred', value: 100 },
  { name: 'truthy', value: true },
  { name: 'falsy', value: false },
  { name: 'estring', value: '2.71828' },
];

var keyBy = (array, fn) => {
  return array.reduce((acc, value) => {
    acc[fn(value)] = value;
    return acc;
  }, {});
};

var keyByForEach = (array, fn) => {
  var acc = {};
  _.forEach(array, (value) => {
    acc[fn(value)] = value;
  });
  return acc;
};

var keyByForLoop = (array, fn) => {
  var acc = {};
  for (let i = 0; i < array.length; i++) {
    acc[fn(array[i])] = array[i];
  }
  return acc;
};

Tests:

lodash/keyBy
_.keyBy(data, (v) => v.name);
keyBy with native reduce
keyBy(data, (v) => v.name);
keyBy with forEach
keyByForEach(data, (v) => v.name);
keyBy with for loop
keyByForLoop(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 with forEach
keyBy with for loop

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the benchmark.

**Overview**

The benchmark measures the performance of three approaches to creating an object where each key is determined by applying a function to an element in an array. The three approaches are:

1. Using Lodash's `keyBy` function
2. Implementing a native `reduce` function
3. Iterating over the array with a `forEach` loop

**Options Compared**

The benchmark compares the performance of these three approaches on the same input data.

**Pros and Cons of Each Approach:**

1. **Lodash's `keyBy` Function**
	* Pros:
		+ Easy to use and understand
		+ Fast, since it uses a native `reduce` implementation under the hood
	* Cons:
		+ Requires Lodash library to be included
2. **Native `Reduce` Function**
	* Pros:
		+ Fast, as it leverages the optimized JavaScript engine's reduce implementation
		+ Does not require any additional libraries
	* Cons:
		+ May require more manual memory management (e.g., handling null values)
3. **ForEach Loop**
	* Pros:
		+ Easy to understand and implement
	* Cons:
		+ Slower than the native `reduce` function or Lodash's `keyBy`
		+ Requires manual index management

**Library:**

The benchmark uses Lodash, a popular JavaScript utility library. The `keyBy` function is a part of Lodash's core functionality and is used to create an object where each key is determined by applying a function to an element in an array.

**Special JS Features/Syntax:**

This benchmark does not use any special JavaScript features or syntax beyond what is considered standard today.

**Other Considerations:**

When choosing between these approaches, consider the trade-offs:

* Performance: Native `reduce` and Lodash's `keyBy` are likely to be faster than a `forEach` loop.
* Code Complexity: A `forEach` loop may require more manual memory management and index tracking, making it less maintainable than the other two options.

**Alternatives:**

Other approaches to creating an object where each key is determined by applying a function to an element in an array might include:

* Using `Array.prototype.reduce()` or `Map`
* Implementing a custom iterative solution using indexes and arrays
* Utilizing specialized libraries like Ramda or Immutable.js

Keep in mind that these alternatives may have their own performance characteristics, trade-offs, and code complexity considerations.

Latest run results:

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

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

Browser/OS: Chrome 129 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
lodash/keyBy	2727430.5 Ops/sec
keyBy with native reduce	3158707.2 Ops/sec
keyBy with forEach	2388515.8 Ops/sec
keyBy with for loop	3297318.2 Ops/sec

Related benchmarks:

lodash/keyBy vs native reduce (version: 0)

Comparing performance of: lodash/keyBy vs keyBy with native reduce vs keyBy with forEach vs keyBy with for loop

Created: 3 years ago by: Registered User

Jump to the latest result

lodash/keyBy

keyBy with native reduce

keyBy with forEach

keyBy with for loop

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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