Benchmark: merge object by key from array with lodash

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/npm/lodash@4.17.5/lodash.min.js"></script>

Script Preparation code:

var key = 'key';

var object = {
  'a': {
    'key': 'a',
    'foo': 123123,
    'bar': 123,
    'fobar': 456
  }
};

var array = [
  {
    'key': 'b',
    'foo': 67563,
    'bar': 6345,
    'fobar': 3425
  },
  {
    'key': 'c',
    'foo': 34532,
    'bar': 123412,
    'fobar': 534532
  },
  {
    'key': 'd',
    'foo': 1234321,
    'bar': 435234,
    'fobar': 346457
  },
  {
    'key': 'e',
    'foo': 23523,
    'bar': 124325,
    'fobar': 2134235
  },
  {
    'key': 'f',
    'foo': 1235213,
    'bar': 346346,
    'fobar': 213423
  }
];

Tests:

Array.prototype.reduce()
array.reduce(function(acc, cur) { acc[cur[key]] = cur; return acc; }, Object.assign({}, object));
_.reduce()
_.reduce(array, function(acc, cur) { acc[cur[key]] = cur; return acc; }, Object.assign({}, object));
_.reduce() with _.get()
_.reduce(array, function(acc, cur) { acc[_.get(cur, key)] = cur; return acc; }, Object.assign({}, object));
_.keyBy()
Object.assign({}, object, _.keyBy(array, key));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.prototype.reduce()
_.reduce()
_.reduce() with _.get()
_.keyBy()

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 dive into the benchmark analysis.

**Benchmark Overview**

The provided JSON represents a set of JavaScript microbenchmarks, specifically focusing on three approaches for merging an object by key from an array: using `Array.prototype.reduce()`, Lodash's `_.reduce()` function, and another variant with `.get()` helper. The benchmarks aim to measure the performance differences between these methods.

**Options Compared**

The three test cases compare:

1. **`Array.prototype.reduce()`**: This is a built-in JavaScript method that applies a reduce operation to an array.
2. **Lodash's `_.reduce()` function**: A utility function from the Lodash library, which provides a more convenient and flexible way to perform reductions.
3. **`.reduce()` with `.get()` helper**: An additional variant of Lodash's `_.reduce()` function that uses the `.get()` method to safely access nested properties.

**Pros and Cons**

Here are some pros and cons for each approach:

1. **`Array.prototype.reduce()`**:
	* Pros: Native performance, easy to understand and implement.
	* Cons: Requires manual handling of edge cases (e.g., empty arrays) and is less readable than other approaches.
2. **Lodash's `_.reduce()` function**:
	* Pros: Convenient, flexible, and handles many edge cases automatically.
	* Cons: External dependency on Lodash, which may not be desirable for all projects.
3. **`.reduce()` with `.get()` helper**:
	* Pros: Combines the benefits of both approaches (convenience and safety) while maintaining a low external dependency.
	* Cons: Introduces an additional layer of complexity due to the use of `.get()`, which may make it harder to understand for some developers.

**Library: Lodash**

Lodash is a popular JavaScript utility library that provides a wide range of functions, including `reduce()` and other helpful methods. It's often used in applications where concise code is desired or when working with nested data structures.

**Special JS Feature/Syntax: None mentioned**

Since there are no special JavaScript features or syntaxes being tested, we can focus on the performance differences between the three approaches.

**Other Alternatives**

For those looking for alternative solutions, consider:

1. **`.forEach()`**: Another approach to iterate over arrays and merge objects by key.
2. **`Array.reduce.call()`**: A way to call `reduce()` as a method on an array-like object.
3. **`_.assignIn()` function from Lodash**: Similar to `.reduce()`, but uses the `_` namespace's convenience functions.

These alternatives might offer different trade-offs in terms of performance, readability, and convenience, making them suitable for specific use cases or preferences.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36

Browser/OS: Chrome 121 on Windows

View result in a separate tab

Test name	Executions per second
Array.prototype.reduce()	1190398.5 Ops/sec
_.reduce()	1075433.4 Ops/sec
_.reduce() with _.get()	512104.6 Ops/sec
_.keyBy()	1224186.9 Ops/sec

Related benchmarks:

merge object by key from array with lodash (version: 0)

Comparing performance of: Array.prototype.reduce() vs _.reduce() vs _.reduce() with _.get() vs _.keyBy()

Created: 6 years ago by: Guest

Jump to the latest result

Array.prototype.reduce()

_.reduce()

_.reduce() with _.get()

_.keyBy()

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):