Benchmark: Lodash cloneDeep vs JSON Clone vs Deepcopy

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...'
    }
};

var myCopy = null;

var isObject = (unknown) => !!unknown && unknown.constructor === Object
var isArray = (unknown) => !!unknown && unknown.constructor === Array
    
var deepCopy = (obj) => {  
    var objCopy = obj

    if (Array.isArray(obj)) {
        objCopy = [...obj]
        for (var i = 0; i < objCopy.length; i += 1) {
            if (Array.isArray(objCopy[i] || isObject(objCopy[i]))) {
                objCopy[i] = deepCopy(objCopy[i])
            }
        }
        return objCopy
    }
    if (isObject(obj)) {
        objCopy = {
            ...obj,
        }
        var keysArray = Object.keys(objCopy)
        for (var i = 0; i < keysArray.length; i += 1) {
            if (typeof objCopy[keysArray[i]] === 'object') {
                deepCopy(objCopy[keysArray[i]])
            }
        }
        return objCopy
    }
    return objCopy
}

Tests:

Lodash cloneDeep
myCopy = _.cloneDeep(MyObject);
Json clone
myCopy = JSON.parse(JSON.stringify(MyObject));
DeepCopy
myCopy = deepCopy(MyObject);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash cloneDeep
Json clone
DeepCopy

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON and explain what's being tested.

**Benchmark Definition**

The benchmark is designed to compare the performance of three different methods for creating a deep copy of an object:

1. `_.cloneDeep` from Lodash
2. `JSON.parse(JSON.stringify())`
3. A custom implementation called `deepCopy`

These methods are used to create a new, independent copy of an object, which is essential in scenarios like data serialization, deserialization, and caching.

**Options Compared**

The benchmark compares the performance of these three methods under various conditions:

* Each method is tested with a different input (same object)
* The same object is used as input for each method

**Pros and Cons**

Here's a brief summary of the pros and cons of each approach:

1. `_.cloneDeep` from Lodash:
	* Pros: Easy to use, well-maintained, and optimized for performance.
	* Cons: Requires Lodash library, which may not be included in all environments.
2. `JSON.parse(JSON.stringify())`:
	* Pros: Simple and widely supported, but can be slow due to JSON serialization overhead.
	* Cons: May not work correctly with certain data types (e.g., functions, sets), and can lead to memory leaks if not used carefully.
3. Custom implementation (`deepCopy`):
	* Pros: Allows for fine-grained control over the copying process, but requires more effort to implement correctly.
	* Cons: Requires manual handling of different data types, which can be error-prone.

**Library and Purpose**

The `_.cloneDeep` function from Lodash is a utility function that creates a deep copy of an object. It recursively traverses the object's properties and creates new copies of each one, ensuring that all nested objects and arrays are also copied.

**Special JS Features or Syntax**

There are no special JavaScript features or syntax used in this benchmark. The code uses standard ECMAScript features and syntax.

**Other Considerations**

When dealing with data serialization and deserialization, it's essential to consider factors like:

* Performance: Creating a deep copy can be an expensive operation, especially for large objects.
* Memory usage: Creating multiple copies of the same object can lead to memory leaks if not managed carefully.
* Data type support: Some methods may not work correctly with certain data types (e.g., functions, sets).

**Alternatives**

Other alternatives for creating deep copies include:

* `Array.prototype.slice()`: Creates a shallow copy of an array.
* `Object.assign()`: Creates a shallow copy of an object.
* Other libraries or frameworks that provide similar functionality to Lodash.

Overall, the benchmark provides a useful comparison of three different methods for creating deep copies in JavaScript, highlighting the trade-offs between simplicity, performance, and maintainability.

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/86.0.4240.111 Safari/537.36

Browser/OS: Chrome 86 on Windows

View result in a separate tab

Test name	Executions per second
Lodash cloneDeep	181265.5 Ops/sec
Json clone	128601.8 Ops/sec
DeepCopy	199374.5 Ops/sec

Related benchmarks:

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

Comparing performance of: Lodash cloneDeep vs Json clone vs DeepCopy

Created: 3 years ago by: Guest

Jump to the latest result

Lodash cloneDeep

Json clone

DeepCopy

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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