Benchmark: Object.assign vs for-in performance

Script Preparation code:

const itemA = { name: 'itemA', things: ['one', 2, 'three', Symbol('four')] };
const itemB = { name: 'itemB', otherThings: { fieldOne: 1, fieldTwo: 'two' } };

Tests:

For-in assignment
// Object.assign() is at least 4x slower than a "for in" loop const fastObjectAssign = (target, source) => { if (!source || !target) return target; for (let key in source) target[key] = source[key]; return target; };
Object.assign mutable assignment
const directAssign = (target, source) => { return Object.assign(target, source); };
Object.assign immutable assignment
const directAssign = (target, source) => { return Object.assign({}, target, source); };

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
For-in assignment
Object.assign mutable assignment
Object.assign immutable assignment

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the benchmark analysis.

The provided JSON represents a microbenchmarking test for comparing the performance of `Object.assign` with two different approaches: using a traditional `for-in` loop and using an immutable assignment.

**Options being compared:**

1. **Traditional Object Assign**: The first approach uses the `Object.assign()` method directly on the target object, passing it both the source and target objects as arguments.
2. **For-In Loop Assignment**: The second approach uses a traditional `for-in` loop to iterate over the properties of the source object and assigns each property to the target object.
3. **Immutable Object Assign**: The third approach uses the `Object.assign()` method on an immutable copy of the source object, passing it both the source and target objects as arguments.

**Pros and Cons:**

1. **Traditional Object Assign**:
	* Pros: Simple, straightforward implementation. Works well for most cases.
	* Cons: May have performance issues when dealing with large or complex objects.
2. **For-In Loop Assignment**:
	* Pros: Can be more efficient for large or complex objects since it only iterates over the properties of the source object.
	* Cons: Requires manual iteration, which can lead to errors if not implemented correctly.
3. **Immutable Object Assign**:
	* Pros: Avoids potential performance issues with `Object.assign()` by creating a separate copy of the source object.
	* Cons: May introduce additional overhead due to the creation and management of an immutable object.

**Library/Functionality:** The benchmark uses the built-in JavaScript function `Object.assign()`, which is part of the ECMAScript standard. This function was introduced in ECMAScript 2015 (ES6) and provides a concise way to copy properties from one object to another.

**Special JS feature or syntax:** There are no special features or syntax used in this benchmark beyond what is considered standard JavaScript.

**Other considerations:**

* The benchmark uses Chrome 105 as the browser, which might not be representative of all users' browsers.
* The test cases use desktop platforms, so results may vary on mobile devices or other operating systems.

**Alternative approaches:**

1. **Other assignment methods**: There are alternative assignment methods available in JavaScript, such as `Object.create()`, `Array.prototype.push()` and `JSON.parse()`. These methods might be used in different scenarios, but they are not the focus of this benchmark.
2. **Object cloning libraries**: There are third-party libraries available that provide more efficient object cloning mechanisms, such as Lodash's `cloneDeep()` function. However, these libraries are not typically used for simple assignment operations like this one.

Overall, this benchmark helps to evaluate the performance characteristics of different assignment methods in JavaScript, providing insights into which approach is most suitable for specific use cases.

Latest run results:

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

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

Browser/OS: Chrome 105 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
For-in assignment	1024513344.0 Ops/sec
Object.assign mutable assignment	1027168000.0 Ops/sec
Object.assign immutable assignment	1022717504.0 Ops/sec

Related benchmarks:

Object.assign vs for-in performance (version: 0)

Comparing performance of: For-in assignment vs Object.assign mutable assignment vs Object.assign immutable assignment

Created: 5 years ago by: Guest

Jump to the latest result

For-in assignment

Object.assign mutable assignment

Object.assign immutable assignment

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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