Benchmark: Object.defineProperty vs Object.assign vs. Direct property assignment

Script Preparation code:

var input = new Array(1000).fill().map((v, i) => i)

Tests:

Object.defineProperty
const output = input.reduce((acc, value) => Object.defineProperty(acc, `key${value}`, { value }), {});
Object.assign (immutable)
const output = input.reduce((acc, value) => Object.assign({}, acc, { [`key${value}`]: value }), {});
Object.assign (mutable)
const output = input.reduce((acc, value) => Object.assign(acc, { [`key${value}`]: value }), {});
Direct assign
const output = input.reduce((acc, value) => (acc[`key${value}`] = value, acc), {});

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.defineProperty
Object.assign (immutable)
Object.assign (mutable)
Direct assign

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64; rv:148.0) Gecko/20100101 Firefox/148.0

Browser/OS: Firefox 148 on Linux

View result in a separate tab

Test name	Executions per second
Object.defineProperty	3323.7 Ops/sec
Object.assign (immutable)	28.1 Ops/sec
Object.assign (mutable)	2500.1 Ops/sec
Direct assign	4854.1 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided benchmark measures the performance difference between three approaches to assign properties to an object in JavaScript:

1. `Object.defineProperty`
2. `Object.assign` with mutable objects
3. Direct property assignment using bracket notation (`[]`)

**Options Comparison**

Here's a brief overview of each option, their pros and cons, and other considerations:

### 1. `Object.defineProperty`

* **Pros:**
	+ Provides more fine-grained control over the assigned properties.
	+ Allows for better error handling when assigning invalid property names.
* **Cons:**
	+ Can be slower than direct assignment due to the overhead of defining a descriptor object.
	+ May require additional setup and configuration.
* **Other Considerations:** `Object.defineProperty` is often used when working with complex data structures or when you need to enforce specific property descriptors.

### 2. `Object.assign` (mutable)

* **Pros:**
	+ Can be faster than direct assignment due to the optimized implementation of `Object.assign`.
	+ Provides a simple and concise way to assign properties.
* **Cons:**
	+ Modifies the original object, which can lead to unexpected behavior if not handled properly.
	+ May cause issues with object inheritance or prototype chains.
* **Other Considerations:** When working with immutable objects or when you want to ensure that the original object remains unchanged.

### 3. Direct assign (using bracket notation `[]`)

* **Pros:**
	+ Fastest of all three options due to its simplicity and lack of overhead.
	+ Provides direct access to the assigned property without any additional setup.
* **Cons:**
	+ Can lead to typos or invalid property names, resulting in errors.
	+ May not provide enough control over the assigned properties.

**Library and Special JS Features**

There are no libraries used in this benchmark. However, `Object.assign` uses the ES6 implementation of the method, which provides a more efficient and concise way to assign properties compared to older implementations.

No special JavaScript features or syntax are used in this benchmark.

**Benchmark Results Analysis**

The provided benchmark results show that direct assignment using bracket notation (`[]`) is the fastest option, followed by `Object.assign` (mutable) with an execution rate significantly slower than the other two options. `Object.defineProperty` performs moderately well but still lags behind direct assignment.

Keep in mind that these results may vary depending on the specific use case and environment. Additionally, the choice of approach depends on the specific requirements and constraints of your project.

**Other Alternatives**

If you're looking for alternative approaches or have specific use cases, consider the following options:

* Using `Object.create` to create a new object and assign properties.
* Utilizing JavaScript's built-in `Map` data structure to store and retrieve properties.
* Leveraging modern JavaScript features like `let` and `const` declarations, along with `Object.assign` methods for more efficient property assignment.

These alternatives may provide better performance, control, or flexibility in specific scenarios, but they also come with their own set of trade-offs and considerations.

Related benchmarks:

Object.defineProperty vs Object.assign vs. Direct property assignment (version: 0)

Comparing performance of: Object.defineProperty vs Object.assign (immutable) vs Object.assign (mutable) vs Direct assign

Created: 4 years ago by: Guest

Jump to the latest result

Object.defineProperty

Object.assign (immutable)

Object.assign (mutable)

Direct assign

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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