Benchmark: Object cloning with Lodash clone vs cloneDeep vs merge vs ES6 object spread vs ES6 Object.assign vs Clone

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>
<script src='https://unpkg.com/clone@2.1.2/clone.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)
Clone
const a = clone(o)
JSON
const a = JSON.parse(JSON.stringify(o))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash cloneDeep
Clone
JSON

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**What is being tested?**

The provided benchmark measures the performance of different approaches for creating a shallow copy of an object in JavaScript.

**Options compared:**

1. **Lodash `cloneDeep`**: A function that creates a deep copy of an object, recursively cloning all nested objects and arrays.
2. **Native `JSON.parse(JSON.stringify())`**: A method that converts a JSON string back to a JavaScript object, which can be used to create a shallow copy of an object.
3. **Lodash `clone`**: A function that creates a shallow copy of an object, cloning only the top-level properties and not recursively cloning nested objects or arrays.
4. **ES6 object spread operator (`{ ... }`)**: A method that creates a new object by spreading the properties of an existing object into it.
5. **ES6 `Object.assign()`**: A method that copies all enumerable own properties from one or more source objects to a target object.
6. **Native `Object.assign()`**: A method that copies all enumerable own properties from one or more source objects to a target object.

**Pros and Cons of each approach:**

* **Lodash `cloneDeep`**:
	+ Pros: Recursively clones nested objects and arrays, ensuring data integrity.
	+ Cons: May be slower due to the recursive cloning process.
* **Native `JSON.parse(JSON.stringify())`**:
	+ Pros: Fast and lightweight, as it only requires a single string conversion.
	+ Cons: Only creates a shallow copy, which may not preserve nested objects or arrays.
* **Lodash `clone`**:
	+ Pros: Faster than `cloneDeep`, as it only clones top-level properties.
	+ Cons: Does not recursively clone nested objects or arrays.
* **ES6 object spread operator (`{ ... }`) and ES6 `Object.assign()`**:
	+ Both create shallow copies, but the object spread operator is more concise and often faster.
	+ Pros: Fast and lightweight, as they only require a single property assignment.
	+ Cons: Do not preserve nested objects or arrays.
* **Native `Object.assign()`**:
	+ Pros: Fast and lightweight, as it only requires a single property assignment.
	+ Cons: May have performance issues if used with large objects or arrays.

**Library and purpose descriptions:**

1. **Lodash**: A popular utility library for JavaScript that provides various functions for tasks such as array manipulation, object cloning, and more.
2. **Clone**: A lightweight library that provides a simple way to create shallow copies of objects.

**Special JS features or syntax:**

None mentioned in the benchmark definition. However, it's worth noting that the use of `let` and `const` declarations (e.g., `var o = ...`) is specific to JavaScript 6+ versions.

**Other alternatives:**

1. **Recursion-based object cloning**: This approach involves manually writing a recursive function to clone an object.
2. **Proxies**: This approach involves using JavaScript's Proxy API to create a proxy that recursively clones nested objects and arrays.

Keep in mind that the choice of implementation will depend on the specific requirements of your project, such as performance, code readability, and data integrity.

Latest run results:

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

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

Browser/OS: Firefox 91 on Linux

View result in a separate tab

Test name	Executions per second
Lodash cloneDeep	139686.7 Ops/sec
Clone	77917.9 Ops/sec
JSON	297258.4 Ops/sec

Related benchmarks:

Object cloning with Lodash clone vs cloneDeep vs merge vs ES6 object spread vs ES6 Object.assign vs Clone (version: 0)

Comparing performance of: Lodash cloneDeep vs Clone vs JSON

Created: 4 years ago by: Guest

Jump to the latest result

Lodash cloneDeep

Clone

JSON

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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