Benchmark: Lodash cloneDeep vs JSON Clone Array

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: '1 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...'
  }
},{
  description: '2 Creates a deep copy of source, which should be an object or an array.',
  myNumber: 987654321,
  myBoolean: false,
  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:

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.

The provided JSON represents a JavaScript benchmark test case on the MeasureThat.net website. The test compares two approaches for creating a deep copy of an object: using Lodash's `cloneDeep` function and manually cloning an array using `JSON.parse(JSON.stringify())`.

**Lodash's `cloneDeep` approach**

*   This method creates a new, independent copy of the original object, including all nested objects and arrays.
*   The purpose of `cloneDeep` is to safely create copies of complex data structures in JavaScript.

Pros:

*   It provides a convenient way to create deep copies without having to manually implement recursive cloning.
    *   It handles cyclic references (i.e., objects that reference themselves) by skipping over them during the cloning process.
*   However, it may introduce additional overhead due to its internal implementation and any potential caching mechanisms.

Cons:

*   Lodash is a library that needs to be included in the benchmark code, which can increase the overall size of the script.
    *   If not properly configured, `cloneDeep` might return incorrect results for certain edge cases (e.g., when dealing with circular references).

**Manual cloning using `JSON.parse(JSON.stringify())`**

*   This approach manually clones an array by converting it to a JSON string and then parsing that string back into an object.
*   However, this method has some limitations:

*   It does not handle cyclic references correctly. If the original object contains a reference to itself, the cloned version will also reference the original object, causing infinite recursion when attempting to clone its contents.
    *   It only works for primitive types and basic objects (e.g., arrays, objects). More complex data structures, such as custom classes or functions, are not supported.

Pros:

*   This method is often simpler to understand and implement, especially for small, simple cloning tasks.
*   However, it has significant limitations due to its inability to handle cyclic references and more complex data structures.

**Considerations**

When choosing between these two approaches, consider the following factors:

*   Performance: Lodash's `cloneDeep` is generally faster and more efficient than manual cloning using `JSON.parse(JSON.stringify())`.
*   Complexity: If the original object contains complex data structures (e.g., custom classes or functions), Lodash's `cloneDeep` might be a better choice.
*   Cyclic references: Be aware that both methods handle cyclic references differently. Manual cloning may fail to correctly clone objects with circular references, while Lodash's `cloneDeep` can handle them.

**Other alternatives**

If you need more advanced features or performance optimizations for your cloning tasks, consider using:

*   `JSON.parse(JSON.stringify(obj))`: This method can be used as a fallback when Lodash's `cloneDeep` is not available.
*   Other libraries like `immutability-helper`, `deepcopy`, or `json-cloned`.
*   Native JavaScript methods and functions (e.g., `Object.assign()`, `Array.prototype.slice()`), although they may have limitations for complex data structures.

In conclusion, when choosing between Lodash's `cloneDeep` and manual cloning using `JSON.parse(JSON.stringify())`, consider the trade-offs in terms of performance, complexity, and handling cyclic references.

Related benchmarks:

Lodash cloneDeep vs JSON Clone Array (version: 0)

Comparing performance of: Lodash cloneDeep vs Json clone

Created: 5 years ago by: Guest

Jump to the latest result

Lodash cloneDeep

Json clone

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