Benchmark: Lodash cloneDeep vs JSON Cloneeeee

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...'
  },
  array:  [
    {
        ali: 1,
        veli: {
            deli: "hee"
        }
    },
    {
        ali: 1,
        veli: 3
    },
    {
        ali: 1,
        veli: {
            deli: "yoo"
        }
    },
    {
        ali: 1,
        veli: 5
    }
]
};

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.

Let's break down what's being tested in this benchmark.

**What is being tested?**

The test measures the performance difference between two approaches: using Lodash's `cloneDeep` function and using the built-in `JSON.parse(JSON.stringify())` method to create a deep copy of an object.

**Options compared**

Two options are being compared:

1. **Lodash cloneDeep**: This method creates a deep copy of an object by recursively cloning its properties.
2. **JSON Cloneeeee (JSON.parse(JSON.stringify()))**: This method converts the original object to a JSON string, and then parses it back into an object.

**Pros and Cons**

* **Lodash cloneDeep**:
	+ Pros: Can handle complex objects with circular references, provides more control over the cloning process.
	+ Cons: Requires additional library (Lodash), can be slower due to its recursive nature.
* **JSON.parse(JSON.stringify())**:
	+ Pros: Fast, lightweight, and widely supported.
	+ Cons: Can fail if the object contains non-serializable properties (e.g., functions, dates), does not handle circular references.

**Library**

The Lodash library is being used to provide the `cloneDeep` function. The purpose of this library is to provide a set of reusable functions for common programming tasks, such as array manipulation and object cloning.

**Special JS feature or syntax**

There are no special JavaScript features or syntaxes mentioned in this benchmark. However, it's worth noting that the use of `JSON.parse(JSON.stringify())` relies on the fact that JavaScript's `toString()` method can serialize objects to a string, and then the `JSON.parse()` method can parse that string back into an object.

**Other alternatives**

If you're looking for alternative approaches to deep copying objects in JavaScript, some options include:

* Using the built-in `Array.prototype.slice()` method with a custom function to clone arrays and objects.
* Utilizing libraries like Immutable.js or React's `cloneDeep` function (which is similar to Lodash's).
* Implementing a custom recursive cloning function using a technique like " proto-based copying".

Keep in mind that each of these alternatives has its own trade-offs in terms of performance, complexity, and library dependencies.

Related benchmarks:

Lodash cloneDeep vs JSON Cloneeeee (version: 0)

Comparing performance of: Lodash cloneDeep vs Json clone

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