Benchmark: Object.defineProperty vs Object.assign vs key set

Script Preparation code:

var input = new Array(100).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 }), {});
Key set
const output = input.reduce((acc, value) => { acc[`key${value}`] = value; return 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)
Key set

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/110.0.0.0 Safari/537.36

Browser/OS: Chrome 110 on Windows

View result in a separate tab

Test name	Executions per second
Object.defineProperty	23681.8 Ops/sec
Object.assign (immutable)	782.9 Ops/sec
Object.assign (mutable)	23770.5 Ops/sec
Key set	114520.6 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down what's being tested in this benchmark.

**Benchmark Purpose:**
The goal of this benchmark is to compare the performance of three approaches for adding properties to an object:

1. `Object.defineProperty()`
2. `Object.assign()` (with and without creating a new immutable object)

**Options Compared:**

* **Immutable Object Creation:** Some benchmarks create a new, empty object using `Object.create(null)` or similar methods to ensure the existing object is not modified accidentally.
* **Mutable Object Modifiers:** In other benchmarks, the existing object is assumed to be mutable and can be safely modified without creating a copy.

**Pros and Cons of Each Approach:**

*   **Immutable Object Creation:** Advantages:
    *   Ensures the original object remains unchanged, reducing potential side effects.
    *   Can improve code readability by making it clear that the original object is not being modified.
    *   Disadvantages:
    *   May result in additional overhead due to creating a new object.
*   **Mutable Object Modifiers:** Advantages:
    *   Can be faster since only one operation is needed (modifying the existing object).
    *   Often more straightforward and idiomatic for many programming languages.

Disadvantages:

*   If modifications lead to unintended side effects on other parts of the codebase.
*   May result in a less explicit understanding of the code's behavior, potentially leading to errors or unexpected results.

**Library Usage:**
In this benchmark, none of the provided JavaScript libraries are explicitly mentioned. However, `Object.create(null)` can be seen as using a part of the ECMAScript standard library (specifically, the `Object` prototype).

**Special JS Feature/Syntax:**
This benchmark does not explicitly mention any special features or syntax that might affect its behavior.

Now, let's move on to other alternatives for creating and modifying objects in JavaScript. Some other approaches include:

1.  **Destructuring assignment:** This is a shorthand way of creating new objects by extracting properties from existing ones.
    ```javascript
const { key1: value1, key2: value2 } = input;
```
2.  **Spread operators:** The spread operator (`...`) can be used to create new arrays or objects by spreading an array into an existing object or vice versa.
    ```javascript
const output = { ...input.reduce((acc, value) => ({ ...acc, [value]: value }), {}) };
```
3.  **Object_initializer syntax:** JavaScript also allows direct initialization of object properties using the Object initializer syntax (the `key:value` pair format).
    ```javascript
const output = input.reduce((acc, value) => ({ key: value }), {});
```

Related benchmarks:

Object.defineProperty vs Object.assign vs key set (version: 0)

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

Created: 4 years ago by: Guest

Jump to the latest result

Object.defineProperty

Object.assign (immutable)

Object.assign (mutable)

Key set

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