Benchmark: Object.assign vs. JSON String/Parse tdamon

Tests:

Spread operator
var n = {foo: 'bar', hello: [{hello: 'world', foo: 'bar'},{hello: 'world', foo: 'bar'},{hello: 'world', foo: 'bar'},{hello: 'world', foo: 'bar'}]}; while(n.length < 1000) { n = {...n}; }
JSON Parse
var n = {foo: 'bar', hello: [{hello: 'world', foo: 'bar'},{hello: 'world', foo: 'bar'},{hello: 'world', foo: 'bar'},{hello: 'world', foo: 'bar'}]}; while(n.length < 1000) { n = JSON.parse(JSON.stringify(n)) }
Object.assign
var n = {foo: 'bar', hello: [{hello: 'world', foo: 'bar'},{hello: 'world', foo: 'bar'},{hello: 'world', foo: 'bar'},{hello: 'world', foo: 'bar'}]}; while(n.length < 100) { n = Object.assign({}, n); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Spread operator
JSON Parse
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.

Let's break down the provided benchmark and explain what is being tested, compared options, pros and cons of those approaches, and other considerations.

**Benchmark Overview**

The benchmark compares three different methods for creating and manipulating objects in JavaScript:

1.  **Spread Operator**: Creating a new object reference using the spread operator (`{...n}`).
2.  **JSON Parse/Parse String**: Using `JSON.parse(JSON.stringify(n))` to create a deep copy of an object.
3.  **Object.assign**: Using `Object.assign({}, n)` to create a shallow copy of an object.

**Benchmark Comparison**

Here's a brief overview of each method:

*   **Spread Operator ( `{...n}` ) **: This method creates a new object reference by spreading the properties of `n` into a new object. The resulting object is not a deep copy, but rather a shallow copy of the original object's properties.
    *   Pros: Lightweight and fast, as it only copies the top-level properties of the object.
    *   Cons: Does not work for objects with complex structures or nested arrays.
*   **JSON Parse/Parse String ( `JSON.parse(JSON.stringify(n))` )**: This method creates a deep copy of an object by serializing it to JSON and then parsing the resulting string back into a new object. However, this approach can be slow and may not work for all types of objects (e.g., Date objects).
    *   Pros: Works for complex structures and nested arrays, but can be slow.
    *   Cons: May not work for certain types of objects (e.g., Date objects), and can be slower than the spread operator.
*   **Object.assign ( `Object.assign({}, n)` )**: This method creates a shallow copy of an object by assigning its properties to a new object. It works well for simple objects, but may not work as expected for complex structures or nested arrays.
    *   Pros: Works well for simple objects and is generally faster than JSON parsing.
    *   Cons: Does not work for complex structures or nested arrays.

**Other Considerations**

*   **Memory Usage**: All three methods have different memory implications. The spread operator creates a new object reference with the same size as the original object, while Object.assign creates a shallow copy that uses less memory. JSON parsing can be slower and may use more memory due to string creation.
*   **Browser Support**: While all three methods are supported by modern browsers, older browsers may not support some of these features.

**Latest Benchmark Results**

The latest benchmark results show the performance differences between the three methods:

*   The spread operator performs best with 706660864 executions per second (Chromium 80 on Ubuntu).
*   JSON parsing is slightly slower than the spread operator but faster than Object.assign.
*   Object.assign is the slowest of the three, likely due to its shallow copying nature.

**Alternatives**

If you need a more robust or efficient way to copy objects in JavaScript, consider using libraries like Lodash's `_.cloneDeep()` function or the `copy` library. These libraries provide deep cloning capabilities and can be more reliable than manual implementation methods.

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Ubuntu Chromium/80.0.3987.87 Chrome/80.0.3987.87 Safari/537.36

Browser/OS: Chromium 80 on Ubuntu

View result in a separate tab

Test name	Executions per second
Spread operator	698308928.0 Ops/sec
JSON Parse	706660864.0 Ops/sec
Object.assign	693634432.0 Ops/sec

Related benchmarks:

Object.assign vs. JSON String/Parse tdamon (version: 0)

Creating a "new" object reference every time

Comparing performance of: Spread operator vs JSON Parse vs Object.assign

Created: 4 years ago by: Guest

Jump to the latest result

Spread operator

JSON Parse

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