Benchmark: Object.assign vs direct assignment multiple properties 2

Script Preparation code:

var data = {};

Tests:

Direct Assignment
for(var i = 0; i < 10000; i++) { data[`prop_${i}`] = true; data[`prop_${i}1`] = true; data[`prop_${i}2`] = true; data[`prop_${i}3`] = true; data[`prop_${i}4`] = true; data[`prop_${i}5`] = true; data[`prop_${i}6`] = true; data[`prop_${i}7`] = true; data[`prop_${i}8`] = true; data[`prop_${i}9`] = true; data[`prop_${i}10`] = true; data[`prop_${i}11`] = true; data[`prop_${i}12`] = true; }
Object.assign
for(var i = 0; i < 10000; i++) { Object.assign(data, { [`prop_${i}`]: true, [`prop_${i}1`]: true, [`prop_${i}2`]: true, [`prop_${i}3`]: true, [`prop_${i}4`]: true, [`prop_${i}5`]: true, [`prop_${i}6`]: true, [`prop_${i}7`]: true, [`prop_${i}8`]: true, [`prop_${i}9`]: true, [`prop_${i}10`]: true, [`prop_${i}11`]: true, [`prop_${i}12`]: true }); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Direct Assignment
Object.assign

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Measuring the performance of JavaScript microbenchmarks is an essential task for web developers and researchers alike.

The provided JSON represents two individual test cases: "Direct Assignment" and "Object.assign". Both tests aim to measure the performance difference between direct assignment of multiple properties to an object versus using the `Object.assign()` method.

**Options being compared:**

1. **Direct Assignment**: Assigning multiple properties to an object using dot notation (e.g., `data[prop_i] = true;`).
2. **Object.assign()**: Using the `Object.assign()` method to assign multiple properties to an object.

**Pros and Cons of each approach:**

* **Direct Assignment**:
	+ Pros:
		- Typically faster, as it involves fewer function calls and less overhead.
		- Can be more readable, especially for simple assignments.
	+ Cons:
		- May not work well with complex objects or nested properties.
		- Can lead to naming conflicts if multiple properties have the same name.
* **Object.assign()**:
	+ Pros:
		- Allows for easy assignment of multiple properties from an object.
		- Works well with complex objects and nested properties.
	+ Cons:
		- Typically slower, due to the function call overhead.
		- May require more code to achieve the same result.

**Library and purpose:**

In this benchmark, `Object.assign()` is a built-in JavaScript method. Its primary purpose is to assign multiple values to an object, returning the modified object.

**Special JS feature or syntax:**

None mentioned in this specific benchmark. However, it's worth noting that some older versions of JavaScript (e.g., ECMAScript 3) did not have the `Object.assign()` method. In those cases, developers would use other methods, such as assigning properties directly to an object.

**Other alternatives:**

If direct assignment is too slow or cumbersome, other alternatives for assigning multiple properties include:

* **Array.prototype.forEach()**: Assigning each property using `forEach()` and pushing it into the object.
* **Object.create() + Object.assign()**: Creating a new object with `Object.create()` and then assigning properties using `Object.assign()`.
* **for...in** loop: Iterating over an array or object's properties using a `for...in` loop and assigning each property individually.

Keep in mind that these alternatives might have their own performance implications and may not always be the best choice for every use case.

Latest run results:

Run details: (Test run date: 4 months ago)

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

Browser/OS: Chrome 125 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Direct Assignment	58.4 Ops/sec
Object.assign	20.3 Ops/sec

Related benchmarks:

Object.assign vs direct assignment multiple properties 2 (version: 0)

Comparing performance of: Direct Assignment vs Object.assign

Created: 5 months ago by: Guest

Jump to the latest result

Direct Assignment

Object.assign

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