Benchmark: lodash groupBy vs Object.groupBy 500k

HTML Preparation code:

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

Script Preparation code:

const max2 = 500000;
var rows = [];

for (let i = 0; i <= max2; i++) {  // Use `let` for `i` as it’s updated in each loop iteration
  rows.push({
    id: i,
    task_id: i % 1000,
    name: `Task ${i}`,
    status: i % 2 === 0 ? 'active' : 'inactive',
    description: `Description for task ${i}`,
    priority: Math.floor(Math.random() * 5) + 1
  });
}

Tests:

Lodash with _.mapValues and _.omit
const lodashMapValuesOmitGrouped = _.mapValues(_.groupBy(rows, 'task_id'), group => group.map(row => _.omit(row, 'task_id')) );
Native reduce Grouping with Destructuring
const nativeReduceGrouped = rows.reduce((acc, row) => { const { task_id, ...rest } = row; // Exclude `task_id` using destructuring if (!acc[task_id]) acc[task_id] = []; // Initialize array for this `task_id` acc[task_id].push(rest); // Add the item without `task_id` to the group return acc; }, {});
Custom reduce with Object.keys Filtering
const customReduceGrouped = rows.reduce((acc, row) => { if (!acc[row.id]) acc[row.id] = []; // Initialize an array for each unique id const rowData = Object.keys(row).reduce((obj, key) => { if (key !== 'id') obj[key] = row[key]; // Exclude 'id' to avoid nesting return obj; }, {}); acc[row.id].push(rowData); return acc; }, {});
Lodash Grouping with Native Key Removal
const lodashGroupedWithDelete = _.groupBy(rows, 'task_id'); Object.values(lodashGroupedWithDelete).forEach(group => { group.forEach(item => { delete item.task_id; // Remove `task_id` directly from each item }); });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash with _.mapValues and _.omit
Native reduce Grouping with Destructuring
Custom reduce with Object.keys Filtering
Lodash Grouping with Native Key Removal

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 22 days ago):

LLMs can make mistakes. Check important info.

The benchmark at MeasureThat.net compares different JavaScript methods for grouping an array of objects based on a specific property (`task_id`). The benchmark tests four different approaches to achieve this:

1. **Lodash with `_.mapValues` and `_.omit`**:
   - **Description**: This approach first groups the `rows` array into an object based on `task_id` using `_.groupBy`, and then applies `_.mapValues` to omit the `task_id` from each grouped item.
   - **Pros**: It offers a clear and functional programming style, leveraging Lodash's utility functions for improved readability and expressiveness.
   - **Cons**: It may introduce overhead due to multiple function calls, potentially affecting performance, especially on larger datasets.

2. **Native `reduce` Grouping with Destructuring**:
   - **Description**: This method uses the native `Array.prototype.reduce` function along with destructuring to group the items. The `task_id` is excluded directly in the destructuring assignment for each row.
   - **Pros**: It is a pure JavaScript solution that avoids external dependencies, potentially leading to better performance.
   - **Cons**: The syntax may be less intuitive for less experienced developers compared to lodash's higher-level abstractions.

3. **Custom `reduce` with `Object.keys` Filtering**:
   - **Description**: This original approach uses `reduce`, iterating through the keys of each object. It manually filters out the `id` key for each object in the grouping process.
   - **Pros**: This method grants full control over how keys are handled and can be customized as needed.
   - **Cons**: It may be less efficient due to multiple object key accesses and might result in more complex code that is harder to read.

4. **Lodash Grouping with Native Key Removal**:
   - **Description**: This approach uses `_.groupBy` from Lodash to create groups and then iterates through each group to delete `task_id` directly from each object using the `delete` operator.
   - **Pros**: This method combines Lodash's grouping capabilities with JavaScript's native `delete`, providing a straightforward way to remove keys.
   - **Cons**: Using `delete` can be slow, as it alters the structure of each object and may result in performance penalties, especially in tight loops or large datasets.

### Performance Results:
Based on the benchmark results executed on a specific browser, we see the following performances (measured in executions per second):

- **Lodash Grouping with Native Key Removal**: 45.26 executions/sec (fastest)
- **Native `reduce` Grouping with Destructuring**: 16.82 executions/sec
- **Custom `reduce` with `Object.keys` Filtering**: 8.79 executions/sec
- **Lodash with `_.mapValues` and `_.omit`**: 3.15 executions/sec (slowest)

### Other Considerations:
- **Readability vs Performance**: While libraries like Lodash can enhance code readability and simplify complex operations, they may not always be the most performant solution for larger datasets. Developers often need to strike a balance between maintaining readable code and optimizing performance.
- **Alternatives**: Alternatives to Lodash include using vanilla JavaScript methods, like `reduce` and `map`, which have the combined benefit of being part of the standard language with no external dependencies. There are also other utility libraries, such as Ramda, that offer similar functionality with functional programming paradigms.
- **Babel/Transpilation**: If modern JavaScript features (like destructuring) are used, it may require a build step if targeting older environments that do not support ES6.

In conclusion, this benchmark provides valuable insights into the trade-offs between using a dedicated library and using native JavaScript methods under different scenarios involving data manipulation and object grouping.

Latest run results:

Run details: (Test run date: 18 days ago)

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

Browser/OS: Chrome 130 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Lodash with _.mapValues and _.omit	2.8 Ops/sec
Native reduce Grouping with Destructuring	14.5 Ops/sec
Custom reduce with Object.keys Filtering	8.4 Ops/sec
Lodash Grouping with Native Key Removal	44.2 Ops/sec

Related benchmarks:

lodash groupBy vs Object.groupBy 500k (version: 7)

Comparing performance of: Lodash with _.mapValues and _.omit vs Native reduce Grouping with Destructuring vs Custom reduce with Object.keys Filtering vs Lodash Grouping with Native Key Removal

Created: 22 days ago by: Registered User

Jump to the latest result

Lodash with _.mapValues and _.omit

Native reduce Grouping with Destructuring

Custom reduce with Object.keys Filtering

Lodash Grouping with Native Key Removal

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 22 days ago):