Benchmark: Reduce with spread operator vs without on a large array 2

Script Preparation code:

var array = new Array(10000).fill(1)

function withSpread(item, index) {
    return {
        [`group${index}`]: {
            id: index,
            timestamp: new Date(new Date().getTime() + (index * 1000)),
            isOdd: index % 2 === 0,
            isEven: index % 2 !== 0
        }
    }

}

function withOutSpread(acc, item, index) {
    acc[index] = {
        id: index,
        timestamp: new Date(new Date().getTime() + (index * 1000)),
        isOdd: index % 2 === 0,
        isEven: index % 2 !== 0
    }
    return acc;
}

Tests:

reduce with spread
Object.assign({}, ...array.map(withSpread))
reduce without spread
array.reduce(withOutSpread, {})

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
reduce with spread
reduce without spread

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 what's being tested in this benchmark.

**Benchmark Definition JSON**

The website `MeasureThat.net` provides a JavaScript microbenchmarking tool, and we're testing two approaches to reduce an array of 10,000 elements:

1. `reduce with spread operator (`Object.assign({}, ...array.map(withSpread))`)
2. `reduce without spread operator (`array.reduce(withOutSpread, {})`))

**Options Compared**

The two options being compared are:

* Using the spread operator (`...`) to create a new object from the array map result
* Not using the spread operator and instead modifying the accumulator directly (`acc[index] = ...`)

**Pros and Cons of Each Approach**

1. **Reduce with Spread Operator**
	* Pros:
		+ Creates a new object, which might be more predictable and efficient for some use cases.
		+ Reduces memory allocation and garbage collection overhead.
	* Cons:
		+ May lead to higher memory usage due to the creation of a new object.
		+ Might incur additional overhead for array map and spread operator operations.
2. **Reduce without Spread Operator**
	* Pros:
		+ Avoids creating a new object, reducing memory allocation and garbage collection overhead.
		+ Can be faster since it modifies the accumulator directly.
	* Cons:
		+ May lead to unpredictable behavior or side effects if not handled carefully (e.g., modifying the original array).
		+ Might require more complex code to manage the accumulator correctly.

**Library Usage**

The benchmark uses the `array.prototype.reduce()` method, which is a built-in JavaScript function. The `withOutSpread` function modifies the accumulator directly using `acc[index] = ...`, while the `withSpread` function creates a new object using spread operator (`...`) to create an intermediate result.

**Special JS Feature or Syntax**

There are no special features or syntax being tested in this benchmark. It's a straightforward comparison of two approaches to reduce an array.

**Other Alternatives**

If you wanted to test alternative approaches, you could consider:

* Using `for` loop instead of `reduce()` for both cases
* Using other reduction functions like `forEach()`, `map()`, or `every()`
* Adding additional complexity to the benchmark, such as inserting random values into the array during execution

These alternatives would provide more comprehensive insights into performance and efficiency under different scenarios.

Latest run results:

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

User agent: Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Mobile Safari/537.36

Browser/OS: Chrome Mobile 122 on Android

View result in a separate tab

Test name	Executions per second
reduce with spread	36.7 Ops/sec
reduce without spread	118.3 Ops/sec

Related benchmarks:

Reduce with spread operator vs without on a large array 2 (version: 0)

Reduce with spread operator vs without on a large array

Comparing performance of: reduce with spread vs reduce without spread

Created: 8 months ago by: Guest

Jump to the latest result

reduce with spread

reduce without spread

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):