Benchmark: Lodash cloneDeep vs JSON Clone (Deeper object)

HTML Preparation code:


<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.2/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...',
  jayson: {
    stringify: 'JSON.stringify() method converts a JavaScript value to a JSON string....',
    parse: 'JSON.parse() method parses a JSON string...',
  jayson: {
    stringify: 'JSON.stringify() method converts a JavaScript value to a JSON string....',
    parse: 'JSON.parse() method parses a JSON string...'
  ,
  jayson: {
    stringify: 'JSON.stringify() method converts a JavaScript value to a JSON string....',
    parse: 'JSON.parse() method parses a JSON string...'
  ,
  jayson: {
    stringify: 'JSON.stringify() method converts a JavaScript value to a JSON string....',
    parse: 'JSON.parse() method parses a JSON string...'
  ,
  jayson: {
    stringify: 'JSON.stringify() method converts a JavaScript value to a JSON string....',
    parse: 'JSON.parse() method parses a JSON string...'
  ,
  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 cloneDeep
myCopy = _.cloneDeep(MyObject);
Json clone
myCopy = JSON.parse(JSON.stringify(MyObject));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash cloneDeep
Json clone

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.212 Safari/537.36

Browser/OS: Chrome 90 on Windows

View result in a separate tab

Test name	Executions per second
Lodash cloneDeep	268403.2 Ops/sec
Json clone	139203.4 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON data for the MeasureThat.net JavaScript microbenchmark.

**Benchmark Definition:**
The benchmark measures the performance of two approaches to create a deep copy of an object in JavaScript:

1. Using Lodash (`_.cloneDeep` method)
2. Using the `JSON.parse(JSON.stringify())` method

**Options compared:**

* **Lodash (`_.cloneDeep`)**: The `_.cloneDeep` method from the popular utility library, Lodash, is used to create a deep copy of an object.
	+ Pros:
		- Provides a robust and efficient way to create deep copies of objects.
		- Supports creation of complex data structures like arrays and objects.
	+ Cons:
		- Requires including additional library code (Lodash).
		- May introduce additional dependencies and overhead.
* **`JSON.parse(JSON.stringify())`**: This method uses the `JSON.stringify()` function to convert an object into a JSON string, which can then be parsed back into an object using `JSON.parse()`. The resulting object is a shallow copy of the original.

**Pros and Cons:**

* **Lodash (`_.cloneDeep`)**:
	+ Pros: efficient, supports deep copies, and robust.
	+ Cons: requires additional library code and dependencies.
* **`JSON.parse(JSON.stringify())`**:
	+ Pros: lightweight, easy to implement.
	+ Cons: only creates shallow copies, may not support complex data structures.

**Library Used:**
In this benchmark, the Lodash library is used. Lodash is a popular JavaScript utility library that provides various functions for tasks such as array manipulation, object creation, and more. The `_.cloneDeep` method is specifically designed to create deep copies of objects, making it a convenient choice for this benchmark.

**Special JS Feature or Syntax:**
There are no special features or syntax used in this benchmark beyond standard JavaScript functionality.

**Other Considerations:**

* For large datasets or complex data structures, Lodash (`_.cloneDeep`) might be a better choice due to its robustness and efficiency.
* If memory is a concern and only shallow copies are required, the `JSON.parse(JSON.stringify())` method could be sufficient.

**Alternatives:**
If you need alternative methods for creating deep copies of objects, consider the following options:

1. **`.slice()` and `.concat()`**: These methods can be used to create shallow copies of arrays or objects.
2. **`.Object.assign()`**: This method creates a new object with copies of all properties from an existing object.
3. **`Array.prototype.slice()`** (for array copying)
4. **`Object.create(null)`** (for creating empty objects)

Keep in mind that these alternatives may not provide the same level of robustness or support for complex data structures as Lodash's `_.cloneDeep` method.

Let me know if you'd like further clarification on any of these points!

Related benchmarks:

Lodash cloneDeep vs JSON Clone (Deeper object) (version: 0)

Comparing performance of: Lodash cloneDeep vs Json clone

Created: 3 years ago by: Guest

Jump to the latest result

Lodash cloneDeep

Json clone

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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