Benchmark: Lodash cloneDeep vs Lodash clone

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;

Tests:

Lodash cloneDeep
myCopy = _.cloneDeep(MyObject);
Lodash clone
myCopy = _.clone(MyObject);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash cloneDeep
Lodash clone

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 4 years ago)

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.132 Safari/537.36

Browser/OS: Chrome 80 on Linux

View result in a separate tab

Test name	Executions per second
Lodash cloneDeep	335039.3 Ops/sec
Lodash clone	657667.4 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down what's being tested in the provided JSON benchmark.

**What is being tested?**

The benchmark compares two approaches to create a deep copy of an object using Lodash: `clone` and `cloneDeep`. A deep copy is a new, independent object that contains all the properties of the original object, including nested objects or arrays. The test creates an object `MyObject` with several properties, including `myNumber`, `myBoolean`, and `jayson`, which contains another object.

**Options compared**

The two options being compared are:

1. **`.clone()`**: This method is used to create a shallow copy of the original object, which means it will only copy the top-level properties and not recursively copy nested objects or arrays.
2. **`.cloneDeep()`**: This method is used to create a deep copy of the original object, which means it will recursively copy all properties and nested objects.

**Pros and cons of each approach**

* `.clone()`: This method is faster because it only needs to iterate over the top-level properties of the object, but it will not work correctly if the object contains nested objects or arrays. If you need to create a deep copy, this method may not be suitable.
* `.cloneDeep()` : This method is slower because it needs to recursively iterate over all properties and nested objects. However, it provides a more accurate representation of the original object.

**Library**

Lodash (also known as underscore.js) is a popular JavaScript utility library that provides a collection of functions for common tasks, including array manipulation, string manipulation, and object manipulation. The `clone` and `cloneDeep` methods are part of Lodash's `lodash.clone` module.

**Special JS feature or syntax**

There isn't any special JavaScript feature or syntax used in this benchmark. However, it's worth noting that some versions of Lodash may use some proprietary syntax for certain methods, but this is not the case with `.clone()` and `.cloneDeep()`.

**Other alternatives**

If you need to create a deep copy of an object without using Lodash, you can use a simple recursive function or a library like Immutable.js. Here's an example of a simple recursive function:
```javascript
function deepCopy(obj) {
  if (typeof obj !== 'object') return obj;
  const copy = Array.isArray(obj) ? [] : {};
  for (const key in obj) {
    copy[key] = deepCopy(obj[key]);
  }
  return copy;
}
```
Another option is to use a library like Immutable.js, which provides a `fromJS()` function that can create a deep copy of an object:
```javascript
import { fromJS } from 'immutable';

const obj = fromJS({
  foo: 'bar',
  baz: [1, 2, 3],
});
const copy = obj.toJS();
```
Keep in mind that creating deep copies can be expensive in terms of performance, so it's essential to use the most efficient approach for your specific use case.

Related benchmarks:

Lodash cloneDeep vs Lodash clone (version: 0)

Comparing performance of: Lodash cloneDeep vs Lodash clone

Created: 4 years ago by: Guest

Jump to the latest result

Lodash cloneDeep

Lodash clone

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