Benchmark: Object.groupBy vs Array.reduce 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:

Object.groupBy
Object.groupBy(data, ({ id }) => id)
Array.reduce
data.reduce((acc, item) => { acc[item.id] = item; return acc; }, {})
Lodash groupBy
_.groupBy(data, ({id}) => id)
custom groupBy
// custom groupBy const groupBy = (data, property) => data.reduce((acc, item) => {acc[property] = item; return acc; }, {}) groupBy(data, 'id')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.groupBy
Array.reduce
Lodash groupBy
custom groupBy

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 10 months ago)

User agent: Mozilla/5.0 (Android 13; Mobile; rv:122.0) Gecko/122.0 Firefox/122.0

Browser/OS: Firefox Mobile 122 on Android

View result in a separate tab

Test name	Executions per second
Object.groupBy	66.2 Ops/sec
Array.reduce	420.6 Ops/sec
Lodash groupBy	73.1 Ops/sec
custom groupBy	579.8 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON data and explain what's being tested, compared, and other considerations.

**Benchmark Definition**

The JSON data represents a benchmark test that compares four approaches to group by key: `Object.groupBy`, `Array.reduce`, `Lodash groupBy`, and a custom implementation (`custom groupBy`).

**Test Case Comparisons**

*   **Object.groupBy vs Array.reduce**: These two methods are part of the JavaScript language itself. They have different use cases:
    *   `Object.groupBy`: This method groups objects by a specified key, returning an object with arrays as values. It's designed to work with objects and has some built-in optimizations.
    *   `Array.reduce`: This method applies a function to each element in an array, accumulating a value. When used for grouping, it can be more flexible but might not provide the same performance as `Object.groupBy`.
    *   **Pros of Object.groupBy**:
        *   Built-in optimization and caching
        *   Designed specifically for object grouping
        *   Can take advantage of JavaScript engines' optimizations
    *   **Cons of Object.groupBy**:
        *   Limited to objects with numeric or symbol keys
        *   May not work well with arrays or other data structures
    *   **Pros of Array.reduce**:
        *   Highly flexible and can be used for any type of data structure
        *   Can be more suitable for complex grouping scenarios
        *   Still, it might incur a performance overhead due to its nature.
    *   **Cons of Array.reduce**:
        *   May not have built-in optimizations or caching like `Object.groupBy`
*   **Lodash groupBy vs custom groupBy**: Both methods are designed for grouping data but come with different trade-offs. Here's how they compare:

*   **Pros of Lodash groupBy**:
        *   Built-in utility function from the popular library Lodash
        *   Designed specifically for grouping, which can make it more efficient
        *   Can be a safer choice if the implementation is not optimal.
    *   **Cons of Lodash groupBy**:
        *   Additional dependency on the Lodash library
        *   May incur a performance overhead due to the library's overhead
    *   **Pros of custom groupBy**:
        *   No additional dependency (it's just JavaScript)
        *   Can be optimized specifically for this use case, potentially leading to better performance.
    *   **Cons of custom groupBy**:
        *   Requires manual implementation and optimization

**Other Considerations**

*   **Library Usage**: The benchmark includes a reference to the Lodash library (`lodash.min.js`). This adds an extra dependency that may impact performance or add complexity to the test setup.

The provided JSON data seems well-structured for comparing different approaches to grouping data. It covers various aspects, such as:

*   Performance differences between built-in methods and custom implementations.
*   Trade-offs between flexibility, optimization, and added dependencies (e.g., Lodash).

To further improve this benchmark or create new ones, consider the following ideas:

1.  **Expand the scope**: Test other grouping approaches or data structures to gain a more comprehensive understanding of each method's strengths and weaknesses.

2.  **Consider additional factors**: In addition to performance, assess how well each method handles errors, edge cases, or complex grouping scenarios.

3.  **Explore variations in input data**: Test with different types of input data (e.g., objects with non-numeric keys, arrays, or mixed data structures).

4.  **Add more test cases or variations**: Increase the number of test cases to cover a broader range of use cases and optimize the implementation for better performance.

5.  **Investigate potential optimizations**: Investigate ways to further optimize the implementations for specific scenarios or hardware architectures.

Related benchmarks:

Object.groupBy vs Array.reduce 100k (version: 6)

Comparing performance of: Object.groupBy vs Array.reduce vs Lodash groupBy vs custom groupBy

Created: 10 months ago by: Registered User

Jump to the latest result

Object.groupBy

Array.reduce

Lodash groupBy

custom groupBy

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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