Benchmark: Lodash cloneDeep vs native cloneDeep , fork MapGhost v2

Lodash cloneDeep vs native cloneDeep , fork MapGhost v2 (version: 1)

compare array copy/clone methods without shallow copy

Comparing performance of: Lodash cloneDeep vs Native map deep slice(turns objects into arrays) vs Native JSON parse vs Native map deep slice at 0(turns objects into arrays) vs Recursive deep clone vs Map deep clone

Created: 6 years ago by: Registered User

Jump to the latest result

HTML Preparation code:


<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>

Script Preparation code:

var testArray = [{
  description: 'Random description.',
  testNumber: 123456789,
  testBoolean: true,
  testObject: {
    testString: 'test string',
    testNumber: 12345
  },
  testArray: [{
    myName: 'test name',
    myNumber: 123245
  }]
},{
  description: 'Random description.',
  testNumber: 123456789,
  testBoolean: true,
  testObject: {
    testString: 'test string',
    testNumber: 12345
  },
  testArray: [{
    myName: 'test name',
    myNumber: 123245
  }]
}];

var testCopy = null;

var deepClone = function(obj) {
   var out;
    if (Array.isArray(obj)) {
        out = [];
        for (var index = 0; index < obj.length; ++index) {
            let subArray = obj[index];
            out.push((subArray === null) ? subArray : (subArray instanceof Date) ? new Date(subArray.valueOf()) : (typeof subArray === 'object') ? deepClone(subArray) : subArray);
        }
    } else {
        out = {};
        for (var key in obj) {
            var subObject = obj[key];
            out[key] = subObject === null ? subObject : subObject instanceof Date ? new Date(subObject.valueOf()) : (typeof subObject === 'object') ? deepClone(subObject) : subObject;
            
           
        }
    }
    return out;
};

Tests:

Lodash cloneDeep
testCopy = _.cloneDeep(testArray);
Native map deep slice(turns objects into arrays)
testCopy = testArray.map(arr => testArray.slice());
Native JSON parse
testCopy = JSON.parse(JSON.stringify(testArray));
Native map deep slice at 0(turns objects into arrays)
testCopy = testArray.map(arr => testArray.slice(0));
Recursive deep clone
testCopy = deepClone(testArray);
Map deep clone
testCopy = testArray.map(arr => deepClone(arr));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash cloneDeep
Native map deep slice(turns objects into arrays)
Native JSON parse
Native map deep slice at 0(turns objects into arrays)
Recursive deep clone
Map deep clone

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 months ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36

Browser/OS: Chrome 144 on Windows

View result in a separate tab

Test name	Executions per second
Lodash cloneDeep	531229.3 Ops/sec
Native map deep slice(turns objects into arrays)	11122707.0 Ops/sec
Native JSON parse	831070.9 Ops/sec
Native map deep slice at 0(turns objects into arrays)	11307255.0 Ops/sec
Recursive deep clone	2498924.5 Ops/sec
Map deep clone	2847026.5 Ops/sec

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

LLMs can make mistakes. Check important info.

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

**Benchmark Overview**

The benchmark compares four different approaches for creating deep copies of an array:

1. `_.cloneDeep(testArray)` using Lodash
2. `testArray.map(arr => testArray.slice())`
3. `JSON.parse(JSON.stringify(testArray))`
4. `deepClone(testArray)` (a custom recursive function)

**Approach 1: Lodash cloneDeep**

Lodash provides a `cloneDeep` function that recursively clones an object or array, creating new copies of all nested properties.

Pros:

* Well-tested and widely used
* Provides a simple and efficient way to create deep copies

Cons:

* Requires the Lodash library to be included in the test environment
* May not perform as well for very large arrays due to the overhead of the library

**Approach 2: Native map deep slice**

This approach uses the `map` method to create a new array with shallow copies of each element. The `slice()` method is then used to create a new array with only the first element.

Pros:

* Fast and lightweight
* Does not require any additional libraries

Cons:

* Only creates shallow copies, which may not be suitable for all use cases
* May not perform well for very large arrays due to the overhead of `map` and `slice`

**Approach 3: Native JSON parse**

This approach uses the `JSON.parse(JSON.stringify(testArray))` method to create a deep copy of the array. This method is supported by most modern browsers.

Pros:

* Fast and lightweight
* Does not require any additional libraries

Cons:

* May not work correctly for all types of objects (e.g., dates, functions)
* Can be slow for very large arrays due to the overhead of `JSON.parse` and `JSON.stringify`

**Approach 4: Recursive deep clone**

This approach uses a custom recursive function (`deepClone`) to create a new copy of each object or array in the test array.

Pros:

* Provides a high degree of control over the cloning process
* Can be used for all types of objects

Cons:

* May be slower than other approaches due to the overhead of the custom function
* Requires manual handling of edge cases (e.g., null, undefined)

**Comparison Results**

The benchmark results show that Lodash's `cloneDeep` approach performs consistently well across different browsers and environments. The native `map deep slice` approach is also fast but only creates shallow copies, which may not be suitable for all use cases.

The native `JSON parse` approach is slower than the other two approaches, likely due to the overhead of `JSON.parse` and `JSON.stringify`. However, it still performs well in terms of execution speed.

The custom recursive function (`deepClone`) provides a high degree of control over the cloning process but may be slower than other approaches.

Overall, the benchmark highlights the importance of choosing the right approach for creating deep copies of arrays, depending on performance requirements and use cases.

Related benchmarks: