Benchmark: Lodash cloneDeep vs JSON Clone vs fastDeepClone

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...'
  }
};

function deepClone(preObj) {
    let newObj, value, key;
    if (typeof preObj !== "object" || preObj === null) {
        return preObj;
    }
    newObj = Array.isArray(preObj) ? [] : {}
    for (key in preObj) {
        value = preObj[key];
        newObj[key] = deepClone(value);
    }
    return newObj
}

var myCopy = null;

Tests:

Lodash cloneDeep
myCopy = _.cloneDeep(MyObject);
Json clone
myCopy = JSON.parse(JSON.stringify(MyObject));
Fast deep clone
deepClone(MyObject)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash cloneDeep
Json clone
Fast deep clone

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what is being tested, compared, and their pros and cons.

**Benchmark Test Cases**

The test cases compare three different approaches to create a deep copy of an object: `Lodash cloneDeep`, `JSON Clone`, and `Fast deep clone`.

1. **Lodash cloneDeep**: This approach uses the `lodash` library's `cloneDeep` function to create a deep copy of the object.
2. **JSON Clone**: This approach uses the built-in `JSON.stringify()` method to serialize the object, convert it back to a JSON string using `JSON.parse()`, and then parse the resulting string back into an object.
3. **Fast deep clone**: This approach is implemented as a simple recursive function called `deepClone` that creates a new object with the same properties as the original object.

**Comparison**

The test cases measure the execution time of each approach on the provided object, which contains nested objects and arrays.

**Pros and Cons**

1. **Lodash cloneDeep**: Pros:
	* Efficiently creates deep copies using optimized algorithms.
	* Handles complex data structures like arrays and objects with ease.
	* Well-tested and maintained library.
Cons:
	* Requires an additional dependency (`lodash`).
	* May have performance overhead due to the library's complexity.
2. **JSON Clone**: Pros:
	* Lightweight, no external dependencies required.
	* Easy to implement, as it only uses built-in methods.
Cons:
	* Can lead to slower execution times due to string serialization and parsing.
	* Does not handle complex data structures like arrays well.
3. **Fast deep clone**: Pros:
	* Simple, easy to understand implementation.
	* Handles basic data structures like objects and arrays without issues.
Cons:
	* Recursive function can cause stack overflows for large input sizes.
	* Not optimized for performance or error handling.

**Library Explanation**

The `lodash` library is a popular JavaScript utility library that provides a wide range of functions for tasks such as string manipulation, array and object manipulation, and more. The `cloneDeep` function in particular is designed to create deep copies of complex data structures, making it efficient and convenient for this benchmark.

**Special JS Feature or Syntax**

The test case uses the `let` keyword with the `const` property, which is a shorthand way of declaring variables in JavaScript. This syntax is supported in modern browsers and Node.js environments.

**Other Alternatives**

For creating deep copies of objects, other alternatives include:

1. **Immutable.js**: A library that provides immutable data structures and functions for creating copies.
2. **immer**: A lightweight library for creating immutable copies of objects.
3. ** plain object assignment**: For simple cases, assigning properties directly to a new object can be sufficient.

These alternatives may have different trade-offs in terms of performance, memory usage, or complexity, depending on the specific use case.

Latest run results:

Run details: (Test run date: 9 days ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:132.0) Gecko/20100101 Firefox/132.0

Browser/OS: Firefox 132 on Windows

View result in a separate tab

Test name	Executions per second
Lodash cloneDeep	718782.2 Ops/sec
Json clone	618543.6 Ops/sec
Fast deep clone	3291662.0 Ops/sec

Related benchmarks:

Lodash cloneDeep vs JSON Clone vs fastDeepClone (version: 0)

Comparing performance of: Lodash cloneDeep vs Json clone vs Fast deep clone

Created: 3 years ago by: Guest

Jump to the latest result

Lodash cloneDeep

Json clone

Fast deep clone

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