Benchmark: Clone deep vs Spread vs Stringify

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
myCopy = _.cloneDeep(MyObject);
Spread
myCopy = { ...MyObject }
Stringify
myCopy = JSON.parse(JSON.stringify(MyObject))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash
Spread
Stringify

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.

**Overview**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. The provided benchmark compares the performance of three approaches: using the `_.cloneDeep()` method from Lodash, the spread operator (`...`), and the `JSON.stringify()` and `JSON.parse()` methods.

**Benchmark Description**

The benchmark tests the creation of a deep copy of an object, `MyObject`, which contains several properties: `description`, `myNumber`, `myBoolean`, and a nested object `jayson`. The test creates three copies of this object using different approaches:

1. **Lodash**: Using the `_cloneDeep()` method from Lodash.
2. **Spread**: Using the spread operator (`...`) to create a shallow copy of the object, which is not suitable for deep copying.
3. **Stringify- Parse**: Using the `JSON.stringify()` and `JSON.parse()` methods to serialize and deserialize the object.

**Options Comparison**

The benchmark compares the performance of these three approaches on the same machine:

* **Lodash (_.cloneDeep())**: This method provides a safe and efficient way to create deep copies of objects, especially for complex nested structures.
* **Spread ( {...})**: While convenient, this approach creates a shallow copy of the object, which may not work correctly if the original object has circular references or other complexities. It's also slower than Lodash due to the overhead of the spread operator.
* **Stringify- Parse (JSON.stringify() + JSON.parse())**: This approach involves serializing the object to a string, parsing it back to an object, and then creating a copy from that parsed object. While technically possible, this approach is slower and less efficient than Lodash due to the additional steps involved.

**Pros and Cons**

* **Lodash (_.cloneDeep())**:
	+ Pros: Fast, efficient, and safe for deep copying.
	+ Cons: Requires including the Lodash library.
* **Spread ( {...})**:
	+ Pros: Convenient and simple.
	+ Cons: Creates a shallow copy, which may not work correctly with complex objects.
	+ Cons: Slower than Lodash.
* **Stringify- Parse (JSON.stringify() + JSON.parse())**:
	+ Pros: None significant advantages over Lodash.
	+ Cons: Slower and less efficient than Lodash.

**Library Used**

The benchmark uses the `lodash` library, which provides a utility function `_cloneDeep()` for creating deep copies of objects. The Lodash library is included as a dependency in the HTML preparation code.

**Special JS Features or Syntax**

None mentioned in the provided benchmark definition.

**Alternatives**

If you're looking for alternative approaches to create deep copies of objects in JavaScript, consider the following:

* **Object.assign()**: While not perfect for creating deep copies due to its limitations with circular references, `Object.assign()` can be used as a fallback or in conjunction with other methods.
* **For...of loop and JSON.parse()**: This approach involves serializing the object using `JSON.stringify()` and then parsing it back to an object using `JSON.parse()`, followed by creating a copy from that parsed object.

Related benchmarks:

Clone deep vs Spread vs Stringify (version: 0)

Comparing performance of: Lodash vs Spread vs Stringify

Created: 6 years ago by: Guest

Jump to the latest result

Lodash

Spread

Stringify

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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