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

myCopy = _.cloneDeep(MyObject);
myCopy = _.cloneDeep(MyObject);
myCopy = _.merge({}, MyObject);
myCopy = _.merge({}, MyObject);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
myCopy = _.cloneDeep(MyObject);
myCopy = _.merge({}, MyObject);

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 break down the benchmark and its test cases.

**Benchmark Definition**

The benchmark measures the performance difference between two approaches: using `_.cloneDeep()` from Lodash to create a deep copy of an object, and using `_.merge()` with an empty object `{}` as the target to merge the original object into.

**Options Compared**

The benchmark compares two options:

1. **`.cloneDeep()`**: This method creates a deep copy of the source object, which means it recursively copies all nested properties and values. It's suitable for creating independent copies of complex objects.
2. **`.merge()` with an empty object `{}` as target**: This approach merges the original object into a new object created with `_.merge()`, effectively "flattening" the structure of the source object. While this method can be useful in some situations, it may not preserve the original object's structure and can lead to unexpected behavior if used incorrectly.

**Pros and Cons**

* **`.cloneDeep()`**:
	+ Pros: Preserves the original object's structure, creates a truly independent copy.
	+ Cons: Can be slower for small objects due to overhead of recursive copying.
* **`.merge()` with an empty object `{}` as target**:
	+ Pros: Faster than `.cloneDeep()` for small objects, can be useful when only certain properties need to be preserved.
	+ Cons: May not preserve the original object's structure, can lead to unexpected behavior if used incorrectly.

**Library and Its Purpose**

The benchmark uses Lodash, a popular JavaScript utility library. Specifically, it relies on two functions:

1. **`.cloneDeep()`**: Creates a deep copy of an object, recursively copying all nested properties and values.
2. **`.merge()`**: Merges two objects into one, overwriting target properties with source property values.

**Special JS Feature or Syntax**

None mentioned in the provided benchmark definition.

**Other Alternatives**

For creating deep copies of objects, you can use:

1. `Object.assign({}, ...)` (native JavaScript method)
2. `JSON.parse(JSON.stringify(...))` ( native JavaScript method)

However, these methods may not preserve nested arrays and functions correctly.

Keep in mind that the performance difference between these approaches may vary depending on the specific use case and the size of the objects being copied or merged. The benchmark provided by MeasureThat.net aims to highlight this difference for a specific scenario.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.100 Safari/537.36

Browser/OS: Chrome 69 on Windows

View result in a separate tab

Test name	Executions per second
myCopy = _.cloneDeep(MyObject);	376705.0 Ops/sec
myCopy = _.merge({}, MyObject);	343614.4 Ops/sec

Related benchmarks:

cloneDeep vs merge (version: 0)

Comparing performance of: myCopy = _.cloneDeep(MyObject); vs myCopy = _.merge({}, MyObject);

Created: 6 years ago by: Guest

Jump to the latest result

myCopy = _.cloneDeep(MyObject);

myCopy = _.merge({}, MyObject);

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