Benchmark: spread vs mutation vs Object.assign vs Object.assign (new) for reduce callback

Script Preparation code:

var range = (from, to) => {
    const output = []
    for (var x = from; x < to; x++) {
        output.push(x)
    }
    return output
}

Tests:

with spread operator
range(0, 10).reduce((acc, num) => { return { ...acc, [num]: num } }, {})
with mutation
range(0, 10).reduce((acc, num) => { acc[num] = num return acc }, {})
with object assign
range(0, 10).reduce((acc, num) => { return Object.assign(acc, {[num]: num}) }, {})
with new object assign
range(0, 10).reduce((acc, num) => { return Object.assign({}, acc, {[num]: num}) }, {})
foreach
const output = {}; range(0, 10).forEach((num) => { output[num] = num; });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
with spread operator
with mutation
with object assign
with new object assign
foreach

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Measuring the performance of JavaScript microbenchmarks is essential to understand the efficiency and optimization techniques for different approaches.

**Benchmark Overview**

The provided JSON represents a benchmark that compares four methods for updating an accumulator in a `reduce` callback function:

1. **Spread Operator (Object Spread)**: Using the spread operator (`...`) to create a new object with updated properties.
2. **Mutation**: Directly modifying the existing accumulator object.
3. **Object.assign**: Using the `Object.assign()` method to update the accumulator object.
4. **New Object Assign**: Creating a new object using `Object.assign()` and then updating its properties.

**Comparison of Approaches**

1. **Spread Operator (Object Spread)**:
	* Pros: Creates a shallow copy of the original object, which can be beneficial for large datasets or when preserving existing properties is crucial.
	* Cons: Can be slower due to the overhead of creating a new object and copying its properties.
2. **Mutation**:
	* Pros: Fastest approach since it only updates the existing accumulator object without creating new objects.
	* Cons: May modify unintended parts of the original object, potentially causing unexpected behavior or side effects.
3. **Object.assign**:
	* Pros: A widely supported and efficient method for updating an object.
	* Cons: Can be slower than mutation due to the overhead of copying properties from one object to another.
4. **New Object Assign**:
	* Pros: Provides a clear separation between the original accumulator object and the updated values, making it easier to reason about code behavior.
	* Cons: Slower than mutation and `Object.assign` due to the overhead of creating a new object.

**Library Use**

None of the provided benchmark test cases use any external libraries. The `range()` function is defined in the script preparation code as a simple utility function, which only uses built-in JavaScript features.

**Special JS Features/Syntax**

The benchmark does not use any special JavaScript features or syntax that would require additional explanation. However, it's worth noting that using `let` and `const` for variable declarations, along with template literals (e.g., `${}`), is supported by most modern JavaScript engines and can make the code more readable.

**Other Alternatives**

If none of these approaches were considered, alternative methods to update an accumulator in a `reduce` callback function could include:

1. Using an array of values and indexing into it to access each value.
2. Employing a custom looping mechanism, such as using `for...of` loops or `while` loops.

However, these alternatives would likely introduce additional overhead, making them less efficient than the approaches being compared in this benchmark.

Latest run results:

Run details: (Test run date: 2 years ago)

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 15_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.2 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 15 on iOS 15.2

View result in a separate tab

Test name	Executions per second
with spread operator	218507.7 Ops/sec
with mutation	2739264.5 Ops/sec
with object assign	212606.5 Ops/sec
with new object assign	106038.5 Ops/sec
foreach	2500987.0 Ops/sec

Related benchmarks:

spread vs mutation vs Object.assign vs Object.assign (new) for reduce callback (version: 2)

Comparing performance of: with spread operator vs with mutation vs with object assign vs with new object assign vs foreach

Created: 2 years ago by: Registered User

Jump to the latest result

with spread operator

with mutation

with object assign

with new object assign

foreach

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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