Benchmark: Object.assign vs dot notation performance 2

Script Preparation code:

var target = {};
var alphabet = 'abcdefghijklmnopqrstuvwxyz'.split('');
var source = alphabet.reduce((acc, char) => {
	acc[char] = char;
  return acc;
}, {});

Tests:

Object.assign - single value
Object.assign(target, source['a']);
dot notation - single value
target['a'] = source['a'];
Object.assign - multiple values
Object.assign(target, source);
dot notation - multiple values
Object.keys(source).forEach(elem => target[elem] = source[elem]);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.assign - single value
dot notation - single value
Object.assign - multiple values
dot notation - multiple values

Fastest: N/A

Slowest: N/A

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/123.0.0.0 Safari/537.36

Browser/OS: Chrome 123 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Object.assign - single value	3621408.5 Ops/sec
dot notation - single value	15100701.0 Ops/sec
Object.assign - multiple values	578950.9 Ops/sec
dot notation - multiple values	474553.2 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON benchmark.

**What is tested?**

The provided benchmark tests two approaches to assign properties to an object: `Object.assign()` and dot notation (`target['a'] = source['a'];`). The tests cover three scenarios:

1. Assigning a single value using `Object.assign()`.
2. Assigning multiple values using `Object.assign()`.
3. Assigning multiple values using dot notation.

**Options compared**

The two options being compared are:

1. **`Object.assign()`**: A method that assigns properties from one or more source objects to a target object.
	* Pros:
		+ More concise and expressive than dot notation for assigning multiple values.
		+ Can handle nested objects and arrays.
	* Cons:
		+ May have performance overhead due to the creation of intermediate arrays.
2. **Dot notation (`target['a'] = source['a'];`)**: A shorthand syntax for assigning properties to an object using the dot notation operator.
	* Pros:
		+ Typically faster than `Object.assign()` since it avoids the overhead of creating intermediate objects.
	* Cons:
		+ Less concise and expressive than `Object.assign()`, making it more error-prone.

**Other considerations**

When choosing between these two approaches, consider the following factors:

* **Readability**: If you need to write a lot of assignment code, dot notation might be clearer. However, if you're assigning multiple values, `Object.assign()` can be more concise and easier to read.
* **Performance**: In general, dot notation should be faster since it avoids the overhead of creating intermediate objects. However, the actual performance difference will depend on the specific use case and browser.

**Library**

There is no explicit library mentioned in the benchmark. However, `Object.assign()` relies on the JavaScript object model, which is a fundamental part of the language.

**Special JS feature or syntax**

The benchmark uses `Object.keys()`, `forEach()`, and array reduction (`alphabet.reduce()`) to create the source object. These are all standard JavaScript features, but they might be unfamiliar to some developers.

**Alternatives**

If you're looking for alternative approaches to assignment, consider:

* **`forEach()` with an arrow function**: Instead of using `Object.keys()` and `forEach()`, you could use an arrow function with a `for...of` loop to iterate over the source object's keys.
* **A library like Lodash**: If you need more complex assignment logic or want to avoid inline code, consider using a utility library like Lodash.

In summary, the benchmark tests two approaches to assign properties to an object: `Object.assign()` and dot notation. The choice between these approaches depends on readability, performance, and personal preference.

Related benchmarks:

Object.assign vs dot notation performance 2 (version: 1)

Comparing performance of: Object.assign - single value vs dot notation - single value vs Object.assign - multiple values vs dot notation - multiple values

Created: 4 years ago by: Registered User

Jump to the latest result

Object.assign - single value

dot notation - single value

Object.assign - multiple values

dot notation - multiple values

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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