Benchmark: Lodash cloneDeep vs native cloneDeep

Lodash cloneDeep vs native cloneDeep (version: 11)

compare array copy/clone methods

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 Native map(shallow clone) vs Recursive deep clone vs Map deep clone vs Object.assign shallow clone`

Created: 7 years ago by: Registered User

Go 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));
Native map(shallow clone)
testCopy = testArray.map(arr => arr);
Recursive deep clone
testCopy = deepClone(testArray);
Map deep clone
testCopy = testArray.map(arr => deepClone(arr));
Object.assign shallow clone
testCopy = Object.assign([...testArray]);

Historical Performance Data aggregated from 189 community runs

Desktop Results:

Chrome 163 runs

Native map(shallow clone)

8.9M/s

Object.assign shallow clone

6.0M/s

Native map deep slice at 0(turns objects into arrays)

5.9M/s

Native map deep slice(turns objects into arrays)

5.8M/s

Native JSON parse

542K/s

Map deep clone

432K/s

Lodash cloneDeep

415K/s

Recursive deep clone

391K/s

Fastest: Native map(shallow clone) (22.8x faster)

View exact numbers

✓ Native map(shallow clone): 8,906,210 ops/sec
• Object.assign shallow clone: 5,961,718 ops/sec
• Native map deep slice at 0(turns objects into arrays): 5,864,530 ops/sec
• Native map deep slice(turns objects into arrays): 5,832,828 ops/sec
• Native JSON parse: 541,574 ops/sec
• Map deep clone: 432,492 ops/sec
• Lodash cloneDeep: 414,665 ops/sec
• Recursive deep clone: 390,648 ops/sec

Firefox 19 runs

Native map(shallow clone)

35.1M/s

Object.assign shallow clone

34.2M/s

Native map deep slice(turns objects into arrays)

14.0M/s

Native map deep slice at 0(turns objects into arrays)

12.7M/s

Recursive deep clone

1.9M/s

Map deep clone

1.7M/s

Native JSON parse

442K/s

Lodash cloneDeep

268K/s

Fastest: Native map(shallow clone) (131.1x faster)

View exact numbers

✓ Native map(shallow clone): 35,115,240 ops/sec
• Object.assign shallow clone: 34,248,140 ops/sec
• Native map deep slice(turns objects into arrays): 13,965,987 ops/sec
• Native map deep slice at 0(turns objects into arrays): 12,680,318 ops/sec
• Recursive deep clone: 1,915,546 ops/sec
• Map deep clone: 1,697,078 ops/sec
• Native JSON parse: 442,402 ops/sec
• Lodash cloneDeep: 267,948 ops/sec

Mobile Results:

Chrome 7 runs

Native map(shallow clone)

7.7M/s

Native map deep slice(turns objects into arrays)

5.8M/s

Native map deep slice at 0(turns objects into arrays)

5.6M/s

Object.assign shallow clone

3.8M/s

Native JSON parse

531K/s

Map deep clone

451K/s

Recursive deep clone

394K/s

Lodash cloneDeep

341K/s

Fastest: Native map(shallow clone) (22.6x faster)

View exact numbers

✓ Native map(shallow clone): 7,725,711 ops/sec
• Native map deep slice(turns objects into arrays): 5,769,510 ops/sec
• Native map deep slice at 0(turns objects into arrays): 5,583,068 ops/sec
• Object.assign shallow clone: 3,765,644 ops/sec
• Native JSON parse: 530,742 ops/sec
• Map deep clone: 450,630 ops/sec
• Recursive deep clone: 393,881 ops/sec
• Lodash cloneDeep: 341,408 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

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)
Native map(shallow clone)
Recursive deep clone
Map deep clone
Object.assign shallow clone

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one month ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:151.0) Gecko/20100101 Firefox/151.0

Browser/OS: Firefox 151 on Mac OS X 10.15

View result in a separate tab

Native map(shallow clone)

56.1M/s

Object.assign shallow clone

53.5M/s

Native map deep slice(turns objects into arrays)

28.0M/s

Native map deep slice at 0(turns objects into arrays)

25.1M/s

Recursive deep clone

4.5M/s

Map deep clone

4.3M/s

Native JSON parse

851K/s

Lodash cloneDeep

482K/s

View exact numbers

Test name	Executions per second
✓ Native map(shallow clone)	56,085,468 Ops/sec
Object.assign shallow clone	53,498,904 Ops/sec
Native map deep slice(turns objects into arrays)	28,019,550 Ops/sec
Native map deep slice at 0(turns objects into arrays)	25,103,878 Ops/sec
Recursive deep clone	4,457,585 Ops/sec
Map deep clone	4,344,996 Ops/sec
Native JSON parse	850,566 Ops/sec
Lodash cloneDeep	481,680 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided JSON represents a JavaScript microbenchmarking test case, specifically designed to compare the performance of different methods for cloning and copying arrays in JavaScript.

**Cloning Methods Compared**

The benchmark compares six different methods for cloning or copying arrays:

1. **Native map deep slice**: `testCopy = testArray.map(arr => testArray.slice());`
2. **Native JSON parse**: `testCopy = JSON.parse(JSON.stringify(testArray));`
3. **Object.assign shallow clone**: `testCopy = Object.assign([...testArray]);`
4. **Lodash cloneDeep**: `testCopy = _.cloneDeep(testArray);` (using the Lodash library)
5. **Map deep clone**: `testCopy = testArray.map(arr => _.cloneDeep(arr));`
6. **Recursive deep clone**: `testCopy = function recursiveClone(obj) { return Object.keys(obj).reduce((acc, key) => { acc[key] = recursiveClone(obj[key]); return acc; }, {}); }(testArray);`

**Performance Results**

The benchmark results show the number of executions per second for each method on a specific browser and operating system configuration. The top-performing methods are:

1. **Native map deep slice**: 3,170,140 executions/second
2. **Object.assign shallow clone**: 3,561,60 executions/second
3. **Native JSON parse**: 356,763.6 executions/second

The other methods perform significantly slower.

**Observations and Insights**

* The native map deep slice method is the fastest way to copy an array in JavaScript.
* Object.assign shallow clone is a good alternative to map deep slice when you don't need to preserve the original array structure.
* Native JSON parse is slower than expected, likely due to the overhead of parsing and stringifying objects.
* Lodash cloneDeep is not faster than native methods, despite being popular among developers.
* Map deep clone and recursive deep clone are slower than other methods because they involve multiple iterations over the object's properties.

Overall, this benchmark highlights the importance of choosing the most efficient cloning method for your specific use case.

Lodash cloneDeep vs native cloneDeep (version: 11)

compare array copy/clone methods

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 Native map(shallow clone) vs Recursive deep clone vs Map deep clone vs Object.assign shallow clone

Created: 7 years ago by: Registered User

Go to the latest result

Lodash cloneDeep

Native map deep slice(turns objects into arrays)

Native JSON parse

Native map deep slice at 0(turns objects into arrays)

Native map(shallow clone)

Recursive deep clone

Map deep clone

Object.assign shallow clone

Historical Performance Data aggregated from 189 community runs

Desktop Results:

Chrome 163 runs

Firefox 19 runs

Mobile Results:

Chrome 7 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

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 Native map(shallow clone) vs Recursive deep clone vs Map deep clone vs Object.assign shallow clone`