Benchmark: Deep object cloning with Lodash cloneDeep vs merge

HTML Preparation code:

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

Script Preparation code:

var o = {
 a: {
   b: 1,
   c: 2,
   d: 3,
   j: {
     k: [1,2,3],
     l: [4,5,6]
   },
 },
 e: [1,2,3,4,5,6],
 f: 1,
 g: {
   h: 1,
 }
}

Tests:

Lodash cloneDeep
const a = _.cloneDeep(o)
Lodash merge
const a = _.merge({}, o)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash cloneDeep
Lodash merge

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the benchmark and explain what's being tested.

**Benchmark Overview**

The benchmark is testing two different approaches for deep object cloning: `_.cloneDeep` from Lodash and `_.merge`. The test uses a predefined JavaScript object `o`, which contains nested objects and arrays. The goal is to compare the performance of these two functions in creating a deep copy of this complex object.

**Options Compared**

The benchmark is comparing two options:

1. **Lodash cloneDeep**: This function is designed to create an exact, shallow-by-reference copy of a given value. However, when dealing with deeply nested objects like `o`, it uses a recursive approach to clone the entire structure.
2. **Lodash merge**: This function takes two or more objects and merges them into one, with the resulting object being the recipient of all the properties from the source objects.

**Pros and Cons**

Here are some pros and cons for each option:

**Lodash cloneDeep**

Pros:

* Creates an exact copy of the original object, including nested structures
* Uses a recursive approach to ensure deep cloning

Cons:

* Can be slower due to its recursive nature
* May not perform well with very large objects or deeply nested structures

**Lodash merge**

Pros:

* Faster than cloneDeep since it only needs to iterate over the properties of the source objects
* More efficient when dealing with larger objects or multiple merges

Cons:

* Does not create an exact copy, but rather a new object that combines the properties from all the sources
* May lose some details in the resulting object (e.g., arrays may become references to the original array)

**Other Considerations**

When choosing between these two options, consider the specific requirements of your use case:

* If you need an exact copy of the original object, including nested structures, `cloneDeep` might be a better choice.
* If you're dealing with large objects or need to perform multiple merges, `merge` could be more efficient.

**Library**

The Lodash library is used in this benchmark. It's a popular utility library that provides various functions for tasks like array manipulation, object cloning, and string manipulation.

**Special JS Feature/Syntax**

There are no special JavaScript features or syntaxes being tested in this benchmark. The test only uses standard JavaScript constructs (objects, arrays, functions).

**Alternatives**

If you're looking for alternative approaches to deep object cloning, consider the following options:

1. **JSON.parse(JSON.stringify(obj))**: This method creates a shallow copy of an object by recursively traversing its properties and creating new objects for each nested structure.
2. **Object.assign() + Array.prototype.slice()**: This approach uses `Object.assign()` to create a new object and then uses `Array.prototype.slice()` to deep clone arrays.
3. **A library like fast-json-stamp or json-stringify-safe**: These libraries provide optimized functions for JSON serialization and deserialization, which can be used to create a deep copy of an object.

Keep in mind that each approach has its trade-offs, and the best choice depends on your specific use case and performance requirements.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:86.0) Gecko/20100101 Firefox/86.0

Browser/OS: Firefox 86 on Windows

View result in a separate tab

Test name	Executions per second
Lodash cloneDeep	63755.0 Ops/sec
Lodash merge	55236.7 Ops/sec

Related benchmarks:

Deep object cloning with Lodash cloneDeep vs merge (version: 1)

Comparing performance of: Lodash cloneDeep vs Lodash merge

Created: 3 years ago by: Registered User

Jump to the latest result

Lodash cloneDeep

Lodash merge

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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