Benchmark: lodash groupBy vs Array.reduce 100k with gey generation

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;

const toKey = (item) => item.date.toLocaleDateString()

var data = [];
for (var i = 0; i <= max2; i++) { data.push({ id: i, date: new Date(Date.now() + Math.floor(Math.random()*1000*60*60*24*30)) }); }

Tests:

Lodash
const toKey = (item) => item.date.toLocaleDateString(); _.groupBy(data, toKey)
Native
const toKey = (item) => item.date.toLocaleDateString(); data.reduce((acc, item) => { acc[toKey(item)] = 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.

Let's break down the provided JSON and explain what's being tested.

**Benchmark Definition**

The benchmark is comparing two approaches to group an array of objects by a specific property: `_.groupBy` from Lodash and the native `Array.prototype.reduce` method.

**Options Compared**

1. **Lodash (`_.groupBy`)**: The Lodash library provides a convenient way to group arrays by a key function.
2. **Native (`Array.prototype.reduce`)**: The native approach uses the `reduce` method to accumulate objects in an object, where the keys are determined by the `toKey` function.

**Pros and Cons**

1. **Lodash (`_.groupBy`)**
	* Pros:
		+ More concise and readable code
		+ Provides a convenient way to group arrays without writing custom code
	* Cons:
		+ Adds an external dependency (Lodash library)
		+ May have performance overhead due to the additional function call
2. **Native (`Array.prototype.reduce`)**

Pros:

* No external dependencies or potential performance overhead
* Uses built-in JavaScript methods, which are generally optimized for performance
Cons:

* Requires writing custom code to group objects by a key
* May be less readable than the Lodash approach

**Library: Lodash**

Lodash is a popular JavaScript utility library that provides a wide range of functions for tasks such as array manipulation, object iteration, and more. The `_.groupBy` function takes an array and a key function as input and returns a new array with each element grouped by the key.

**Special JS Feature/Syntax: None**

There are no special JavaScript features or syntax used in this benchmark.

**Other Alternatives**

If you don't want to use Lodash, you can also use other libraries like `underscore` (similar to Lodash) or implement a custom grouping function using `Array.prototype.reduce`.

Alternatively, if you prefer not to use an external library or additional methods, you can also use a technique called "map-reduce" or "groupby-fn" to achieve the same result. This approach involves mapping each element of the array to its corresponding key and then reducing the resulting array using `Array.prototype.reduce`.

Here's an example implementation:
```javascript
const data = [...]; // your data array

const groups = {};
data.forEach((item) => {
  const key = item.date.toLocaleDateString();
  if (!groups[key]) {
    groups[key] = [];
  }
  groups[key].push(item);
});

// Use the resulting groups object in your test
```
This implementation uses a simple object to store the grouped data, but you can modify it to suit your specific needs.

Related benchmarks:

lodash groupBy vs Array.reduce 100k with gey generation (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):