Benchmark: lodash/keyBy vs native reduce 2

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 keyByReduce = (array, key) => {
  return (array || []).reduce((r, x) => ({ ...r, [key ? x[key] : x]: x }), {})
}

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);
keyByReduce
keyByReduce(data, '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
keyByReduce

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) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36 Edg/129.0.0.0

Browser/OS: Chrome 129 on Windows

View result in a separate tab

Test name	Executions per second
lodash/keyBy	4995689.0 Ops/sec
keyBy with native reduce	6515550.5 Ops/sec
keyBy with forEach	3563646.5 Ops/sec
keyBy with for loop	5779602.5 Ops/sec
keyByReduce	1220464.9 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON and explain what is being tested, compared, and the pros/cons of each approach.

**Benchmark Definition**

The benchmark is designed to compare four different approaches for creating an object with key-value pairs from an array:

1. **`keyBy(data, (v) => v.name)`**: Using Lodash's `keyBy` function.
2. **`keyBy(data, (v) => v.name);`**: Using native JavaScript `reduce` method with a custom callback function.
3. **`keyByForEach(data, (v) => v.name);`**: Using Lodash's `forEach` function to iterate over the array and create the object.
4. **`keyByForLoop(data, (v) => v.name);`**: Using a traditional for loop to iterate over the array and create the object.

**What is being compared?**

The benchmark compares the performance of each approach in creating an object with key-value pairs from an array.

**Options being compared:**

1. **Lodash's `keyBy` function**: A library function that takes an array and a callback function as input, and returns an object with key-value pairs.
2. **Native JavaScript `reduce` method**: A built-in method for reducing an array to a single value or an object.
3. **Lodash's `forEach` function**: A utility function for iterating over an array.
4. **Traditional for loop**: A basic loop construct for iterating over an array.

**Pros/Cons of each approach:**

1. **Lodash's `keyBy` function**:
	* Pros: High-level abstraction, concise code, and often faster than native implementations due to optimized C++ implementation.
	* Cons: Additional library dependency, may not be as intuitive for complex use cases.
2. **Native JavaScript `reduce` method**:
	* Pros: Fast, efficient, and widely supported.
	* Cons: Requires manual implementation of callback function logic, can be error-prone if not implemented correctly.
3. **Lodash's `forEach` function**:
	* Pros: Easy to use, concise code, and often faster than traditional for loops due to optimized C++ implementation.
	* Cons: Additional library dependency, may not be as efficient as native implementations for large datasets.
4. **Traditional for loop**:
	* Pros: Simple, intuitive, and easy to understand for beginners.
	* Cons: Can be slow compared to other approaches, especially for large datasets.

**Library usage**

The benchmark uses Lodash's `keyBy` function in two test cases (`_keyBy(data, (v) => v.name)` and `_keyByForEach(data, (v) => v.name)`). The library is loaded via a script tag.

**Special JavaScript feature or syntax**

There are no special JavaScript features or syntaxes used in the benchmark. All approaches rely on standard JavaScript concepts such as arrays, objects, and callback functions.

**Alternatives**

Other alternatives for creating an object with key-value pairs from an array could include:

* Using `Object.fromEntries()` (a newer ES6 feature)
* Utilizing a data structure like a Map or a Set
* Implementing custom loop constructs or recursion

However, these alternatives are not explicitly tested in this benchmark.

Related benchmarks:

lodash/keyBy vs native reduce 2 (version: 0)

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

Created: 5 years ago by: Guest

Jump to the latest result

lodash/keyBy

keyBy with native reduce

keyBy with forEach

keyBy with for loop

keyByReduce

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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