Benchmark: Lodash cloneDeep vs JSON Clone vs freeze and destructure -w/ dates

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...'
  },
  d1: new Date(),
  date2: new Date().setYear(1980)
};

var myCopy = null;

Tests:

Lodash cloneDeep
myCopy = _.cloneDeep(MyObject);
Json clone
myCopy = JSON.parse(JSON.stringify(MyObject));
freeze and destructure
Object.freeze(MyObject); myCopy = { ...MyObject };

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash cloneDeep
Json clone
freeze and destructure

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.1:latest, generated one year ago):

LLMs can make mistakes. Check important info.

Let's dive into the details of this benchmark.

**Benchmark Description**

This benchmark compares the performance of four approaches to create a deep copy of an object:

1. Using Lodash's `cloneDeep` function
2. Using `JSON.parse(JSON.stringify())`
3. Freezing the original object with `Object.freeze()` and then using the spread operator (`{...object}`) to create a shallow copy

**Library Used**

The benchmark uses [Lodash](https://lodash.com/), a popular JavaScript utility library, specifically its `cloneDeep` function.

**JS Feature or Syntax Used**

This benchmark does not use any special JavaScript features or syntax beyond what's available in standard ES5+ browsers. However, it does use the spread operator (`{...object}`) to create a shallow copy of an object, which is a feature introduced in ECMAScript 2018 (ES2018).

**Options Compared**

The four test cases compare the performance of different approaches to create a deep copy of an object:

1. **Lodash cloneDeep**: This approach uses Lodash's `cloneDeep` function to create a deep copy of the original object.
2. **JSON Clone**: This approach uses the `JSON.parse(JSON.stringify())` method to convert the original object to a JSON string and then parse it back into an object, effectively creating a deep copy.
3. **Freeze and Destructure**: This approach freezes the original object with `Object.freeze()` to prevent any modifications, and then uses the spread operator (`{...object}`) to create a shallow copy of the frozen object.

**Pros/Cons**

Here are some pros and cons of each approach:

1. **Lodash cloneDeep**:
	* Pros: Highly efficient and widely supported.
	* Cons: Requires including Lodash in your project, which may add bloat.
2. **JSON Clone**:
	* Pros: Simple to implement and doesn't require any external libraries.
	* Cons: Can be slow for large objects due to the stringification overhead.
3. **Freeze and Destructure**:
	* Pros: Fast and lightweight since it only creates a shallow copy of the frozen object.
	* Cons: May not work as expected if the original object contains functions, symbols, or other non-enumerable properties.

**Other Considerations**

When choosing an approach for creating deep copies of objects, consider the following factors:

1. **Performance**: If speed is critical, Lodash's `cloneDeep` or the freeze-and-destructure approach may be better suited.
2. **Size and complexity**: For small objects with simple structures, the JSON clone method might suffice.
3. **Code simplicity**: If you prioritize code readability and ease of maintenance, the JSON clone method is simpler to understand.

**Alternatives**

Other alternatives for creating deep copies of objects include:

1. Using a custom implementation that recursively clones properties.
2. Employing libraries like `immer` or `deepClone`, which provide more robust and efficient cloning capabilities.
3. Utilizing frameworks like React, which have built-in support for shallow copying components.

These are the key takeaways from this benchmark. Let me know if you'd like me to elaborate on any aspect!

Related benchmarks:

Lodash cloneDeep vs JSON Clone vs freeze and destructure -w/ dates (version: 0)

Comparing performance of: Lodash cloneDeep vs Json clone vs freeze and destructure

Created: 5 years ago by: Registered User

Jump to the latest result

Lodash cloneDeep

Json clone

freeze and destructure

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

Autogenerated LLM Summary (model llama3.1:latest, generated one year ago):