Benchmark: Lodash cloneDeep vs. Lodash clone vs. Array.slice() vs. Array.slice(0) vs. Object.assign()

HTML Preparation code:

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

Script Preparation code:

var arr = ['one', 'two', 'three', {four: 'five'}];

Tests:

Lodash cloneDeep
var myCopy = _.cloneDeep(arr)
Lodash clone
var myCopy = _.clone(arr)
Array.slice()
var myCopy = arr.slice()
Array.slice(0)
var myCopy = arr.slice(0)
Object.assign()
var myCopy = Object.assign([], arr)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash cloneDeep
Lodash clone
Array.slice()
Array.slice(0)
Object.assign()

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 105 on Linux

View result in a separate tab

Test name	Executions per second
Lodash cloneDeep	400338.3 Ops/sec
Lodash clone	2312363.2 Ops/sec
Array.slice()	7494326.5 Ops/sec
Array.slice(0)	7599966.0 Ops/sec
Object.assign()	537148.8 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what is tested, the options compared, their pros and cons, and other considerations.

**Benchmark Definition**

The benchmark is to compare the performance of creating shallow copies of an array using different methods: Lodash `cloneDeep`, Lodash `clone`, `Array.slice()`, `Array.slice(0)`, and `Object.assign()`.

**Options Compared**

1. **Lodash `cloneDeep`**: A deep copy of an object or array, which creates a new, independent copy of the original data structure.
2. **Lodash `clone`**: A shallow copy of an object or array, which creates a new copy of only the top-level properties and does not recursively clone nested objects or arrays.
3. **`Array.slice()`**: Creates a new array containing a subset of elements from the original array, starting at the specified index (0).
4. **`Array.slice(0)`**: Similar to `Array.slice()`, but starts at index 0 and returns a shallow copy of the entire array.
5. **`Object.assign()`**: Copies the values of all enumerable own properties from one or more source objects to a target object.

**Pros and Cons**

1. **Lodash `cloneDeep`**:
	* Pros: Creates a deep, independent copy of the original data structure, which is useful for scenarios where the copied data should not be modified.
	* Cons: Can be slower than shallow copies due to its recursive nature.
2. **Lodash `clone`**:
	* Pros: Faster than `cloneDeep`, as it only creates a new copy of top-level properties and does not recursively clone nested objects or arrays.
	* Cons: Does not create an independent copy, so modifying the cloned data can affect the original.
3. **`Array.slice()`**:
	* Pros: Fast and efficient for creating shallow copies of arrays, as it only creates a new array with a subset of elements.
	* Cons: Returns a new array object, which may have different internal structure than the original array.
4. **`Array.slice(0)`**:
	* Pros: Similar to `Array.slice()`, but starts at index 0 and returns a shallow copy of the entire array.
	* Cons: Also returns a new array object with a subset of elements, which may have different internal structure than the original array.
5. **`Object.assign()`**:
	* Pros: Creates a new target object with copied values from source objects, which can be useful for scenarios where you need to merge data from multiple sources.
	* Cons: Can be slower than shallow copies due to its overhead of creating and copying objects.

**Other Considerations**

1. **Deep vs. Shallow Copies**: Depending on the use case, you may need a deep copy (independent, recursively cloned) or a shallow copy (dependent, only top-level properties cloned). Lodash's `cloneDeep` provides the former, while `clone` and `Object.assign()` provide the latter.
2. **Array vs. Object**: The benchmark uses arrays, but the same principles apply to objects. In some cases, you may need to use different methods for objects versus arrays.

**Alternatives**

If you're looking for alternatives to Lodash or its methods, consider the following:

1. **`JSON.parse(JSON.stringify())`**: Creates a deep copy of an object by parsing the JSON representation of the original object and then stringifying it again.
2. **`lodash-es`**: An ES module version of Lodash, which can provide similar functionality to `cloneDeep`, `clone`, etc.
3. **`immer`**: A library that provides a functional programming approach to working with data structures, including creating immutable copies.

These alternatives may offer different trade-offs in terms of performance, complexity, or feature set, so it's essential to evaluate them based on your specific use case and requirements.

Related benchmarks:

Lodash cloneDeep vs. Lodash clone vs. Array.slice() vs. Array.slice(0) vs. Object.assign() (version: 0)

For times when a shallow copy is needed, what is the performance difference between these 5 methods.

Comparing performance of: Lodash cloneDeep vs Lodash clone vs Array.slice() vs Array.slice(0) vs Object.assign()

Created: 3 years ago by: Guest

Jump to the latest result

Lodash cloneDeep

Lodash clone

Array.slice()

Array.slice(0)

Object.assign()

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