Benchmark: lodash groupBy vs Array.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 max2 = 100000; // 100,000,000 (100 Million)

var data = [];
for (var i = 0; i <= max2; i++) { data.push({ id: i }); }

Tests:

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

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash
Native

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 4 years ago)

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

Browser/OS: Chrome 84 on Mac OS X 10.15.6

View result in a separate tab

Test name	Executions per second
Lodash	138.8 Ops/sec
Native	273.5 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):

LLMs can make mistakes. Check important info.

Let's break down what's being tested in this benchmark.

**Benchmark Overview**

The benchmark compares the performance of two approaches to group an array of objects by a common key: `lodash groupBy` and `Array.reduce`.

**Options Compared**

1. **Lodash**: Uses the `_groupBy` function from the Lodash library, which is a utility library for functional programming in JavaScript.
2. **Native**: Uses the built-in `Array.reduce` method to achieve the same grouping functionality.

**Pros and Cons of Each Approach**

1. **Lodash (`_groupBy`)**:
	* Pros:
		+ Provides a simple and efficient way to group arrays by a common key.
		+ Leverages the power of functional programming in JavaScript.
	* Cons:
		+ Introduces additional overhead due to the use of an external library.
2. **Native (`Array.reduce`)**:
	* Pros:
		+ Does not introduce any additional overhead, as it's a built-in method.
		+ Can be more efficient for large datasets, as it doesn't require creating an intermediate array.
	* Cons:
		+ Requires more manual effort and boilerplate code to achieve the grouping functionality.

**Library: Lodash**

Lodash is a popular utility library for JavaScript that provides a wide range of functional programming helpers. In this case, `_groupBy` is used to group arrays by a common key. Lodash's `groupBy` function takes two arguments: the array to be grouped and a function that extracts the grouping key from each element.

**Special JS Feature/Syntax**

None mentioned in this benchmark.

**Other Alternatives**

If you prefer not to use an external library like Lodash, you could also consider using other libraries or polyfills that provide similar functionality. Some alternatives include:

1. **Underscore.js**: Another popular utility library for JavaScript that provides a `groupBy` function.
2. **Moment.js**: A popular date and time library that provides a `groupBy` method for grouping arrays by a common key.

For the native approach using `Array.reduce`, you could also consider other alternatives like:

1. **D3.js**: A popular data visualization library that provides a `groupBy` function for grouping arrays by a common key.
2. **Ramda**: A functional programming library that provides a `groupBy` function for grouping arrays by a common key.

Keep in mind that these alternatives may introduce additional overhead or require more manual effort to achieve the desired functionality.

Related benchmarks:

lodash groupBy vs Array.reduce (2) (version: 0)

Comparing performance of: Lodash vs Native

Created: 4 years ago by: Guest

Jump to the latest result

Lodash

Native

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):