Benchmark: spread vs assign speed

Script Preparation code:

var target = { a: 1, b: 2 };
var source = { b: 4, c: 5 };

Tests:

spread
const other = { ...target, ...source }
assign
const other = Object.assign(target, source);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
spread
assign

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

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

**Benchmark Overview**

The benchmark, titled "spread vs assign speed", is designed to compare the performance of two approaches: using the spread operator (`...`) to merge objects, and using `Object.assign()` to achieve the same result. The goal is to determine which approach is faster.

**Options Compared**

There are only two options being compared:

1. **Spread Operator (Spreading)**: This method uses the `...` syntax to create a new object by merging the properties of two existing objects.
2. **Object.assign()**: This method uses the `Object.assign()` function to merge the properties of two or more objects.

**Pros and Cons**

* **Spread Operator (Spreading)**:
	+ Pros: Concise, readable, and efficient way to merge objects.
	+ Cons: May not work as expected if the source object contains functions or other non-primitive values. Also, some older browsers may have issues with this syntax.
* **Object.assign()**:
	+ Pros: Widely supported across modern browsers and versions of JavaScript.
	+ Cons: Less readable than spreading, and can lead to issues with function and object assignment.

**Library/Function Usage**

There is no library or function usage in this benchmark. The test cases only involve built-in JavaScript features.

**Special JS Features/Syntax**

There are no special JS features or syntax being used in this benchmark. However, it's worth noting that the spread operator was introduced in ECMAScript 2018 (ES2018), and some older browsers may not support it.

**Other Alternatives**

If you want to compare performance with different approaches, here are a few alternatives:

* Using `Object.assign()` with multiple arguments: `Object.assign(other, source)`
* Using the `reduce()` method with an initial value: `other = { ...target }`.reduce((acc, cur) => ({ ...acc, ...cur }), source)`
* Using the `concat()` method: `other = Object.concat(target, source)`

These alternatives would provide additional insight into how different methods perform in various scenarios.

**Benchmark Result Analysis**

The benchmark result shows that Safari 16 on a Desktop device with Mac OS X 10.15.7 performed:

* Faster execution for the spread operator (`spread`) with an average of 6274710 executions per second.
* Slower execution for `Object.assign()` (`assign`) with an average of 6894249 executions per second.

Keep in mind that browser performance can vary depending on various factors, such as hardware, software, and environment.

Related benchmarks:

spread vs assign speed (version: 0)

Comparing performance of: spread vs assign

Created: 4 years ago by: Guest

Jump to the latest result

spread

assign

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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