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; }, {})

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

Autogenerated LLM Summary (model llama3.2:3b, generated one month 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.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36 Edg/124.0.0.0

Browser/OS: Chrome 124 on Windows

View result in a separate tab

Test name	Executions per second
New native groupBy	26.7 Ops/sec
Old native reduce	284.5 Ops/sec

Related benchmarks:

Reduce vs Object.groupBy (version: 0)

Testing the new native method

Comparing performance of: New native groupBy vs Old native reduce

Created: 9 months ago by: Guest

Jump to the latest result

New native groupBy

Old native reduce

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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