Benchmark: Lodash cloneDeep vs JSON Clone deeper1

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...',
    state: {
		data: {
          items: {
            myMan: {
              test: 1234,
              hanne: "1234",
              items: {
            myMan: {
              test: 1234,
              hanne: "1234"
            }
          }
            }
          }
        }
    }
  }
};

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.

**What is being tested?**

The provided JSON represents two benchmark test cases that compare the performance of `Lodash's cloneDeep` method with the built-in `JSON.parse(JSON.stringify())` method for creating a deep copy of an object.

**Options compared:**

Two options are compared:

1. **Lodash's cloneDeep**: This is a popular JavaScript library function that creates a deep copy of an object, which means it recursively copies all nested properties.
2. **Built-in JSON.parse(JSON.stringify())**: This method uses the `JSON.stringify()` function to convert the original object into a string and then parses it back into an object using `JSON.parse()`. While this method may seem similar to creating a deep copy, it can lead to unexpected behavior if the original object contains circular references.

**Pros and Cons of each approach:**

1. **Lodash's cloneDeep**:
	* Pros:
		+ Creates a true deep copy of the object, avoiding potential issues with circular references.
		+ More efficient than `JSON.parse(JSON.stringify())` for large objects.
	* Cons:
		+ Requires the Lodash library to be included in the test environment.
2. **Built-in JSON.parse(JSON.stringify())**:
	* Pros:
		+ Does not require an additional library, making it a simpler option.
	* Cons:
		+ May fail for objects with circular references, leading to unexpected behavior.

**Library and its purpose:**

The `Lodash` library is a popular JavaScript utility library that provides various functions for tasks such as string manipulation, array operations, and object manipulation. In this case, the `cloneDeep()` function is used to create a deep copy of an object.

**Special JS feature or syntax:**

There are no special features or syntaxes being tested in this benchmark.

**Benchmark preparation code explanation:**

The script prepares two objects: `MyObject` and its clone `myCopy`. The `MyObject` contains nested properties, including a circular reference (`jayson.state.items`). The `cloneDeep()` function is used to create the clone of `MyObject`, while the built-in method uses `JSON.parse(JSON.stringify())`.

**Other alternatives:**

If you're looking for alternative methods to create deep copies of objects in JavaScript, some other options include:

1. **Array.prototype.slice.call()**: This method creates a shallow copy of an object by iterating over its properties and assigning them to new properties on an array.
2. **Object.assign()**: This method creates a shallow copy of an object by copying the properties from one object to another.
3. **for...in loops**: You can use `for...in` loops to iterate over an object's properties and create a deep copy manually.

Keep in mind that these alternatives may have performance implications or limitations compared to using Lodash's `cloneDeep()` function or the built-in `JSON.parse(JSON.stringify())` method.

Related benchmarks:

Lodash cloneDeep vs JSON Clone deeper1 (version: 0)

Comparing performance of: Lodash cloneDeep vs Json clone

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