Benchmark: lodash deep clone vs object assign1

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>

Script Preparation code:

var MyObject = {
  description: 'Creates a deep copy of source, which should be an object or an array.',
  myNumber: 123456789,
  myBoolean: true,
  jayson: {
    stringify: 'JSON.stringify() method converts a JavaScript value to a JSON string....',
    parse: 'JSON.parse() method parses a JSON string...'
  }
};

var myCopy = null;

Tests:

lodash deep clone
myCopy = _.cloneDeep(MyObject);
JS object assign
myCopy = Object.assign({}, MyObject);
Json stringify
myCopy = JSON.parse(JSON.stringify(MyObject));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash deep clone
JS object assign
Json stringify

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 104 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
lodash deep clone	1362698.6 Ops/sec
JS object assign	4630553.0 Ops/sec
Json stringify	669593.9 Ops/sec

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

LLMs can make mistakes. Check important info.

Measuring the performance of different approaches to clone or manipulate JavaScript objects is crucial for understanding the impact on application performance.

**Benchmark Definition**

The benchmark compares three methods to create a deep copy of an object:

1.  **lodash deep clone**: Uses the `_.cloneDeep()` function from the Lodash library, which creates a shallow copy of an object by recursively cloning its properties.
2.  **JS object assign**: Utilizes the `Object.assign()` method to create a new object and then copies the properties from the original object using the spread operator (`...`).
3.  **JSON stringify**: Uses the `JSON.stringify()` function to convert the object into a JSON string, which can be parsed later to recreate the original object.

**Comparison of Approaches**

*   **Lodash deep clone**: This method is generally the fastest because it uses a specialized implementation that takes advantage of the browser's internal object copying mechanisms. However, it has limitations since it only clones shallowly.
*   **JS object assign**: This approach can be slower due to the overhead of creating a new object and then copying properties from the original. Nevertheless, it is more flexible and can handle nested objects deeply.
*  **JSON stringify**: This method is likely the slowest because it involves converting the entire object into a string, which requires additional parsing and creation steps when recreating the object.

**Pros and Cons of Each Approach**

*   Lodash deep clone:
    *   Pros: fast, easy to use, handles shallow cloning.
    *   Cons: can be limited for very complex objects or nested structures.
*   JS object assign:
    *   Pros: flexible, can handle nested objects deeply.
    *   Cons: may be slower due to the overhead of creating a new object and copying properties.
*  JSON stringify:
    *   Pros: handles arbitrary JavaScript values when stringifying (e.g., date or RegExp instances).
    *   Cons: slow, requires additional parsing steps when recreating the object.

**Other Considerations**

*   For very large objects or complex data structures, `_.cloneDeep()` from Lodash might be a good choice due to its optimized implementation.
*   When working with nested objects and arrays, `Object.assign()` with the spread operator (`...`) can be an efficient option.
*  When dealing with specific use cases that require serializing or deserializing arbitrary JavaScript values (e.g., dates, RegExps), using `JSON.stringify()` can be a good approach.

**Alternative Approaches**

Some other approaches to clone or manipulate objects include:

*   **Array.prototype.slice()**: This method creates a shallow copy of an array.
*   **_.clone()` from Lodash: Creates a shallow copy of an object, similar to `_.cloneDeep()`.
*   **`new Object()` and assigning properties manually**: This approach can be manual but allows for complete control over the copying process.

These alternative approaches may offer trade-offs in terms of performance or flexibility compared to the methods mentioned earlier.

Related benchmarks:

lodash deep clone vs object assign1 (version: 1)

lodash deep clone vs object assign

Comparing performance of: lodash deep clone vs JS object assign vs Json stringify

Created: 3 years ago by: Registered User

Jump to the latest result

lodash deep clone

JS object assign

Json stringify

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