Benchmark: Lodash cloneDeep vs native cloneDeep (copy object)

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 testObject = {
  description: 'Random description.',
  testNumber: 123456789,
  testBoolean: true,
  testObject: {
    testString: 'test string',
    testNumber: 12345
  }
};

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(testObject);
Native map deep slice(turns objects into arrays)
testCopy = [testObject].map(arr => [testObject].slice());
Native JSON parse
testCopy = JSON.parse(JSON.stringify(testObject));
Native map deep slice at 0(turns objects into arrays)
testCopy = [testObject].map(arr => [testObject].slice(0));

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)

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/112.0

Browser/OS: Firefox 112 on Ubuntu

View result in a separate tab

Test name	Executions per second
Lodash cloneDeep	556549.0 Ops/sec
Native map deep slice(turns objects into arrays)	9783496.0 Ops/sec
Native JSON parse	670029.0 Ops/sec
Native map deep slice at 0(turns objects into arrays)	9681889.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation of the provided benchmark.

**Benchmark Purpose:**
The purpose of this benchmark is to compare the performance of different methods for creating a deep copy of an object in JavaScript.

**Options Compared:**

1. **Lodash cloneDeep**: This method uses the Lodash library to create a deep copy of the object.
2. **Native map deep slice**: This method uses the `map` and `slice` functions to create a new array with the same elements as the original object, effectively creating a deep copy.
3. **Native JSON parse**: This method uses the `JSON.parse` function to create a deep copy of the object by parsing its string representation.
4. **Native map deep slice at 0**: Similar to the previous option, but it creates an array with the same elements as the original object, but starts from index 0.

**Pros and Cons:**

* **Lodash cloneDeep**:
	+ Pros: Fast and efficient, especially for large objects.
	+ Cons: Requires Lodash library, which can add extra overhead.
* **Native map deep slice**: 
	+ Pros: Fast and lightweight, as it uses built-in functions.
	+ Cons: May not work correctly with certain data types (e.g., dates).
* **Native JSON parse**:
	+ Pros: Simple and straightforward, but may be slower than other options.
	+ Cons: Requires parsing the object's string representation, which can be slow for large objects.
* **Native map deep slice at 0**: 
	+ Pros: Similar to the previous option, but starts from index 0.
	+ Cons: Same limitations as the previous option.

**Library and Syntax:**

The Lodash library is used in the `Lodash cloneDeep` option. Lodash provides a set of utility functions for JavaScript, including the `cloneDeep` function, which creates a deep copy of an object.

The `map`, `slice`, `JSON.parse`, and `new Date()` functions are built-in or native functions in JavaScript.

**Special JS Feature/Syntax:**

This benchmark does not use any special JavaScript features or syntax that would be specific to a particular browser or version. However, it's worth noting that the use of `JSON.parse` can be affected by the browser's JSON parser implementation.

**Alternatives:**

There are other methods for creating deep copies of objects in JavaScript, such as:

* Using the `Array.prototype.slice()` method with the spread operator (`...`)
* Using a recursive function to create a new object with the same properties
* Using a library like Immer or React's `useMemo` hook to manage state updates

However, these alternatives are not tested in this specific benchmark.

Related benchmarks:

Lodash cloneDeep vs native cloneDeep (copy object) (version: 0)

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)

Created: one year ago by: Guest

Jump 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)

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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