Benchmark: Object.assign() vs spread operator (New object)

Script Preparation code:

var a = { a: 'oh', b: 'my' };
var b = { c: 'goddess' };

Tests:

Object.assign()
const c = Object.assign(Object.assign({}, a), b)
Spread operator
const c = {...a, ...b}

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.assign()
Spread operator

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.

**What is being tested?**

The benchmark compares the performance of two approaches to create a new object: `Object.assign()` and the spread operator (`...`).

**Options compared:**

1. **`Object.assign()`**: This method creates a shallow copy of an existing object by assigning properties from one object to another.
2. **Spread operator (`...`)**: This syntax creates a new object by copying all own enumerable properties from source objects.

**Pros and cons of each approach:**

* `Object.assign()`:
	+ Pros: More explicit, easier to understand for some developers.
	+ Cons: Can be slower than the spread operator, especially when dealing with deeply nested objects.
* Spread operator (`...`):
	+ Pros: Faster, more concise, and expressive.
	+ Cons: Less intuitive for developers who are not familiar with it.

**Library and special syntax used:**

There is no specific library being tested in this benchmark. However, the spread operator relies on a modern JavaScript feature called "rest parameter syntax" (`...`), which was introduced in ECMAScript 2015 (ES6).

**Other considerations:**

* The benchmark uses an object `a` with two properties and another object `b` with one property to create a new object.
* The spread operator is used with `{}` to create a new empty object, which allows the comparison to be fair.

**Alternatives:**

If you're interested in creating a new object, there are other methods available:

1. **`Object.create()`**: Creates a new object with the specified prototype.
2. **`Array.prototype.slice()`**: Can be used to create an array copy, which can then be converted to an object using `Object.assign()`.
3. **`JSON.parse()`**: Can be used to parse a JSON string and create a new object.

However, these alternatives might not provide the same level of performance or conciseness as the spread operator for simple use cases.

Latest run results:

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

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

Browser/OS: Chrome 112 on Windows

View result in a separate tab

Test name	Executions per second
Object.assign()	1569993.2 Ops/sec
Spread operator	1161807.1 Ops/sec

Related benchmarks:

Object.assign() vs spread operator (New object) (version: 0)

This benchmark looks at how fast Object.assign() is compared to spread operator when used with {} to make up for the fact that Object.assign() doesn't create a new object

Comparing performance of: Object.assign() vs Spread operator

Created: 2 years ago by: Guest

Jump to the latest result

Object.assign()

Spread operator

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