Benchmark: lodash groupBy vs Array.reduce 100k better

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 }) => id)
Native
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

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.

**Benchmark Overview**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. The provided benchmark tests two approaches for grouping data in an array: `_.groupBy` from the Lodash library, and the native `Array.reduce` method.

**Script Preparation Code**

The script preparation code generates a large dataset of 100,000 objects with a single property `id`, which will be used as input for both test cases. This dataset is created using a simple loop that pushes objects to an array.

**Html Preparation Code**

The HTML preparation code includes a reference to the Lodash library (version 4.17.5) via a CDN link, ensuring that the necessary functionality is available for the `_.groupBy` test case.

**Test Cases**

There are two individual test cases:

1. **Lodash**: The first test case uses the `_groupBy` method from Lodash to group the data by the `id` property.
2. **Native**: The second test case uses the native `Array.reduce` method to achieve the same grouping.

**Options Compared**

The benchmark compares two approaches for grouping data:

1. **Lodash GroupBy**: Uses the `_groupBy` function from Lodash, which is a higher-order function that takes a callback function as an argument.
2. **Native Array Reduce**: Uses the native `Array.reduce` method with a custom callback function to group the data.

**Pros and Cons**

Here are some pros and cons of each approach:

* **Lodash GroupBy**:
	+ Pros: Easy to use, concise code, reliable results.
	+ Cons: Requires an additional library (Lodash), may be slower due to overhead.
* **Native Array Reduce**:
	+ Pros: Native implementation, potentially faster, no external dependencies.
	+ Cons: Requires manual implementation of the grouping logic, can be more verbose.

**Library: Lodash**

The Lodash library provides a convenient and efficient way to perform common JavaScript tasks, including data transformations. The `_groupBy` function is a popular utility that groups data by a specified property.

**Special JS Feature/Syntax: None**

There are no special JavaScript features or syntax used in this benchmark. Both test cases rely on standard JavaScript methods and libraries.

**Alternatives**

If you're interested in exploring alternative approaches, here are some options:

1. **Array.prototype.reduce() with a custom callback**: Similar to the native `Array.reduce` method, but without the built-in grouping functionality.
2. **D3.js GroupBy**: A data visualization library that provides a `groupBy()` function for grouping data.
3. **Other libraries**: There are other JavaScript libraries, such as Ramda or Underscore, that provide similar group-by functionality.

Keep in mind that these alternatives may have different performance characteristics and requirements compared to the native `Array.reduce` method and Lodash's `_groupBy` function.

Related benchmarks:

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

Comparing performance of: Lodash vs Native

Created: 2 years ago by: Guest

Jump to the latest result

Lodash

Native

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