Benchmark: Object from entries - Object.assign vs. spread vs. simple mutate

Script Preparation code:

window.entries = [
  ['one', 1],
  ['two', 2],
  ['three', 3],
  ['four', 4],
  ['five', 5]
];

Tests:

Object.assign
window.entries.reduce((obj, [key, value]) => Object.assign(obj, {[key]: value}), {})
Spread
window.entries.reduce((obj, [key, value]) => ({...obj, [key]: value}), {})
Simple mutate
window.entries.reduce((obj, [key, value]) => { obj[key] = value; return obj; }, {})

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.assign
Spread
Simple mutate

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36

Browser/OS: Chrome 111 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Object.assign	1064047.6 Ops/sec
Spread	1667742.9 Ops/sec
Simple mutate	6850338.5 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark and explain what's being tested, compared, and their pros and cons.

**Benchmark Overview**

The benchmark is designed to test the performance of three different approaches for reconstructing an object from its entries using JavaScript:

1. `Object.assign`
2. The object rest spread operator (`{...obj, [key]: value}`)
3. Simple mutation by assigning values directly (`obj[key] = value`)

**Library and Syntax**

The benchmark uses the following library:

* No explicit libraries are mentioned in the provided JSON. However, the use of `Object.assign` and the object rest spread operator suggests that JavaScript's built-in functionality is being utilized.

As for special JS features or syntax, none are explicitly used in the benchmarked code snippets. The focus is on comparing the performance of three specific approaches to reconstructing an object from its entries.

**Comparison**

Here's a brief overview of each approach and their pros and cons:

1. **Object.assign**
	* This method iterates over the array of key-value pairs, adding each property to the target object using `Object.assign`.
	* Pros:
		+ Widely supported across browsers and platforms.
		+ Can be used with any iterable (not limited to arrays).
	* Cons:
		+ May have performance overhead due to repeated calls to `Object.assign`.
2. **Spread Operator ({...obj, [key]: value})**
	* This method creates a new object by copying the properties from an existing object (`obj`) and adding new key-value pairs.
	* Pros:
		+ Efficient, as it uses a single operation to create a new object with both copied and new properties.
		+ Wide support across modern browsers and platforms.
	* Cons:
		+ May not work in older browsers or environments without support for the spread operator.
3. **Simple Mutation (obj[key] = value)**
	* This method iterates over the array of key-value pairs, assigning each property to the target object directly using dot notation (`obj[key] = value`).
	* Pros:
		+ Lightweight and fast, as it avoids creating a new object.
	* Cons:
		+ May not be suitable for objects with many properties or large arrays, as it can lead to performance issues due to repeated property accesses.

**Benchmark Results**

The latest benchmark results show that the "Simple mutate" approach outperforms both `Object.assign` and the spread operator. This is likely because simple mutation avoids the overhead of creating a new object, which can be beneficial in scenarios where memory is limited or objects are large.

In contrast, `Object.assign` may have performance overhead due to repeated calls to `Object.assign`, while the spread operator's efficiency makes it a good choice for many use cases. However, its wide support across browsers and platforms might make it a preferred option in some situations.

**Alternatives**

If you're looking for alternative approaches or optimization techniques:

* Consider using a library like Lodash, which provides optimized implementations of `Object.assign` and other utility functions.
* If performance is critical, consider using a just-in-time (JIT) compiler or optimizing your code further to reduce overhead.
* For objects with many properties or large arrays, consider using an in-place object merging algorithm or lazy loading techniques to mitigate performance issues.

Keep in mind that these alternatives might not be suitable for all use cases and may introduce additional complexity.

Related benchmarks:

Object from entries - Object.assign vs. spread vs. simple mutate (version: 0)

Tests the difference in performance when reconstructing an object from its entries via reduce, between using Object.assign and the object rest spread operator

Comparing performance of: Object.assign vs Spread vs Simple mutate

Created: one year ago by: Guest

Jump to the latest result

Object.assign

Spread

Simple mutate

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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