Benchmark: lodash groupBy vs Array.reduce vs Array.group 100k

HTML Preparation code:

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

Script Preparation code:

var max2 = 100000;

var data = [];
for (var i = 0; i <= max2; i++) { data.push({ id: i }); }

Tests:

Lodash
_.groupBy(data, 'id')
Native reduce
data.reduce((acc, item) => { if (acc[item.id]) acc[item.id].push(item); else acc[item.id] = [item]; return acc; }, {})

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash
Native reduce

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark definition and test cases.

**Benchmark Definition:**
The benchmark measures the performance of two approaches to group an array of objects by a specific property:

1. `_.groupBy(data, 'id')`: This is a function from the Lodash library that groups an array of objects based on a specified property.
2. `data.reduce((acc, item) => { ... }`: This is a native JavaScript method that uses reduction to group an array of objects by a specific property.

**Options being compared:**

* Lodash's `groupBy` function
* Native JavaScript's `reduce` method

**Pros and Cons of each approach:**

1. **Lodash's `_groupBy` function:**
	* Pros:
		+ Convenient and easy to use, as it's a part of the Lodash library.
		+ Handles edge cases like empty arrays or null/undefined values.
	* Cons:
		+ Adds an extra dependency on the Lodash library, which may not be desirable in all situations.
		+ May have performance overhead due to the library's initialization and garbage collection processes.
2. **Native JavaScript's `reduce` method:**
	* Pros:
		+ No dependencies or overhead from external libraries.
		+ Can be more efficient for large datasets, as it uses a simple iterative approach.
	* Cons:
		+ Requires more manual effort to implement and debug, especially for complex grouping scenarios.
		+ May not handle edge cases like empty arrays or null/undefined values as robustly as Lodash.

**Other considerations:**

* The benchmark prepares an array of 100,000 objects with a unique `id` property using JavaScript's `for` loop. This is done to ensure that the tests are performed on large datasets.
* The Lodash library is included via a CDN link in the HTML preparation code.

**Special JS feature or syntax:**
There isn't any special JavaScript feature or syntax used in this benchmark. It's a straightforward comparison of two grouping approaches.

**Other alternatives:**
If you're looking for alternative ways to group arrays of objects, here are some options:

* **Array.prototype.groupBy**: This is a standard method on the Array prototype that can be used with arrow functions and rest parameters.
```javascript
const groupedData = data.groupBy(item => item.id);
```
* **Map**: You can use a Map to store the groups of objects, where each key is a unique value from the `id` property.
```javascript
const groupedData = new Map();
data.forEach(item => {
  const key = item.id;
  if (groupedData.has(key)) {
    groupedData.get(key).push(item);
  } else {
    groupedData.set(key, [item]);
  }
});
```
* **D3.js**: If you're working with large datasets and need more advanced grouping capabilities, D3.js can be a good option.

These alternatives offer different trade-offs in terms of performance, convenience, and complexity.

Related benchmarks:

lodash groupBy vs Array.reduce vs Array.group 100k (version: 0)

Comparing performance of: Lodash vs Native reduce

Created: 3 years ago by: Guest

Jump to the latest result

Lodash

Native reduce

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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