Benchmark: Object.assign vs iteration performance (Grammarly Focal)

Object.assign vs iteration performance (Grammarly Focal) (version: 0)

Comparing performance of: Iteration with blank object vs Object.assign with blank object vs Iteration with created object vs Object.assign with created object vs Iteration with blank object and prototype vs Object.assign with blank object and prototype vs Iteration with blank object and prototype prop vs Object.assign with blank object and prototype prop

Created: 5 years ago by: Guest

Jump to the latest result

Script Preparation code:

class Rectangle {
    constructor(height, width) {
        this.height = height;
        this.width = width;
    }

    calcArea() {
        return this.height * this.width;
    }
}

var r = new Rectangle(3, 4);

Tests:

Iteration with blank object
var copy = {}; for(const prop in r) copy[prop] = r[prop];
Object.assign with blank object
var copy = {}; Object.assign(copy, r);
Iteration with created object
var copy = Object.create(Object.getPrototypeOf(r)); for(const prop in r) copy[prop] = r[prop];
Object.assign with created object
var copy = Object.create(Object.getPrototypeOf(r)); Object.assign(copy, r);
Iteration with blank object and prototype
var copy = {}; Object.setPrototypeOf(copy, Object.getPrototypeOf(r)); for(const prop in r) copy[prop] = r[prop];
Object.assign with blank object and prototype
var copy = {}; Object.setPrototypeOf(copy, Object.getPrototypeOf(r)); Object.assign(copy, r);
Iteration with blank object and prototype prop
var copy = {}; copy.__proto__ = r.__proto__; for(const prop in r) copy[prop] = r[prop];
Object.assign with blank object and prototype prop
var copy = {}; copy.__proto__ = r.__proto__; Object.assign(copy, r);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Iteration with blank object
Object.assign with blank object
Iteration with created object
Object.assign with created object
Iteration with blank object and prototype
Object.assign with blank object and prototype
Iteration with blank object and prototype prop
Object.assign with blank object and prototype prop

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

The benchmark being measured is the performance difference between three methods to create an object copy from another object:

1. **Iteration**: Using a `for...in` loop to iterate over the properties of the original object and assign them to the new object.
2. **Object.assign() with blank object**: Using `Object.assign()` to copy all enumerable own properties from the original object to a blank object.
3. **Object.assign() with created object**: Using `Object.assign()` to copy all enumerable own properties from the original object to a newly created object.

**Pros and Cons:**

*   **Iteration**:
    *   Pros:
        *   No additional memory allocation is required, as it only creates a temporary new object.
        *   Can be more efficient in some cases when dealing with large objects or complex data structures.
    *   Cons:
        *   May be slower due to the overhead of iterating over properties and handling each one individually.
        *   Requires manual management of the loop and potential issues with property names and types.
*   **Object.assign() with blank object**:
    *   Pros:
        *   Fast and efficient, as it uses optimized internal mechanisms for copying objects.
        *   Relatively simple to use and understand.
    *   Cons:
        *   Requires an additional blank object to be created and discarded, which can incur memory allocation overhead.
*   **Object.assign() with created object**:
    *   Pros:
        *   Fast and efficient, as it uses optimized internal mechanisms for copying objects.
        *   No additional memory allocation is required, other than the temporary creation of a new object.
    *   Cons:
        *   Requires creating a new object using `Object.create()` or another method, which can incur some overhead.

**Other considerations:**

*   **Prototype chain**: In some cases, it's also worth considering the impact of modifying the prototype chain on performance. The provided benchmark includes tests with and without using the prototype chain (`Object.setPrototypeOf()`) to demonstrate this.
*   **Browser-specific differences**: It's essential to note that different browsers may have slightly varying performance characteristics for these methods due to their implementation specifics.

**Alternative approaches:**

Other methods for creating object copies, such as:

1.  **Spread operator (`{...}`)**:
    *   Pros:
        *   Fast and efficient.
        *   Relatively simple to use and understand.
    *   Cons:
        *   Only works with objects that support spread syntax (not all older browsers or environments).
*   **`Object.assign()` with an existing object**:
    *   Pros:
        *   Fast and efficient, as it uses optimized internal mechanisms for copying objects.
        *   Relatively simple to use and understand.
    *   Cons:
        *   Requires an existing object that has the same properties as the original.

The choice of method often depends on the specific requirements and constraints of the project.

Related benchmarks: