Benchmark: Reduce vs Object.groupBy

Script Preparation code:

var max2 = 100000;

var data = [];
for (var i = 0; i <= max2; i++) { data.push({ id: i }); }

Tests:

New native groupBy
Object.groupBy(data, ({ id }) => id)
Old native reduce
data.reduce((acc, item) => { acc[item.id] = item; return acc; }, {})

Historical Performance Data aggregated from 15 community runs

Desktop Results:

Chrome 10 runs

Old native reduce

650/s

New native groupBy

75/s

Fastest: Old native reduce (8.6x faster)

View exact numbers

✓ Old native reduce: 650 ops/sec
• New native groupBy: 75 ops/sec

Firefox 5 runs

Old native reduce

2K/s

New native groupBy

695/s

Fastest: Old native reduce (2.3x faster)

View exact numbers

✓ Old native reduce: 1,626 ops/sec
• New native groupBy: 695 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
New native groupBy
Old native reduce

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:142.0) Gecko/20100101 Firefox/142.0

Browser/OS: Firefox 142 on Mac OS X 10.15

View result in a separate tab

Old native reduce

656/s

New native groupBy

181/s

View exact numbers

Test name	Executions per second
✓ Old native reduce	656 Ops/sec
New native groupBy	181 Ops/sec

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

LLMs can make mistakes. Check important info.

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

**Benchmark Definition**

The benchmark is testing two different approaches to achieve the same result: reducing an array of objects to a grouped object using either the `Object.groupBy` method (new native) or the `reduce` method (old native).

**Test Cases**

There are two test cases:

1. **New native groupBy**: This test case uses the new native `Object.groupBy` method to group the data array by the `id` property of each object.
2. **Old native reduce**: This test case uses the old native `reduce` method to achieve the same result as `Object.groupBy`.

**Options Compared**

The two approaches are compared in terms of performance, which is measured by the number of executions per second.

**Pros and Cons**

* **Object.groupBy (New Native)**:
	+ Pros: This approach is likely to be faster because it's a native method optimized for performance.
	+ Cons: It may not work in older browsers or environments that don't support this feature.
* **Reduce (Old Native)**:
	+ Pros: This approach is widely supported by most browsers and environments, making it a safe choice.
	+ Cons: It might be slower than `Object.groupBy` due to the overhead of looping through each element.

**Library and Purpose**

There is no library mentioned in this benchmark. However, the use of `Object.groupBy` suggests that the test is targeting modern browsers or environments that support this feature.

**Special JS Feature or Syntax**

No special JavaScript features or syntax are used in these test cases. They're relatively simple and straightforward.

**Other Considerations**

* The test data is created by pushing 100,000 objects onto an array, with each object having a unique `id` property.
* The benchmark uses Chrome 124 as the target browser, which suggests that the test is optimized for this specific version.
* The test only runs on desktop platforms, which might limit its relevance to mobile or other device types.

**Alternatives**

If you were to create a similar benchmark, you could consider adding additional test cases, such as:

* Using a different data structure, like an array of arrays
* Adding more complex data structures, like nested objects
* Testing the performance of these methods in different browsers or environments

Keep in mind that the specific approach and data used will impact the results of your benchmark.

Reduce vs Object.groupBy (version: 0)

Testing the new native method

Comparing performance of: `New native groupBy vs Old native reduce`

Created: 2 years ago by: Guest

Go to the latest result

New native groupBy

Old native reduce

Historical Performance Data aggregated from 15 community runs

Desktop Results:

Chrome 10 runs

Firefox 5 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Reduce vs Object.groupBy (version: 0)

Testing the new native method

Comparing performance of: New native groupBy vs Old native reduce

Created: 2 years ago by: Guest

Go to the latest result

New native groupBy

Old native reduce

Historical Performance Data aggregated from 15 community runs

Desktop Results:

Chrome 10 runs

Firefox 5 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `New native groupBy vs Old native reduce`