Benchmark: Lodash cloneDeep vs JSON Clone vs Ramda Clone vs hand rolled vs spread vs obj.assign vs structured clone

HTML Preparation code:


<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.25.0/ramda.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/clone/2.1.2/clone.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);
Json clone
myCopy = JSON.parse(JSON.stringify(MyObject));
Ramda clone
myCopy = R.clone(MyObject);
hand rolled
const cp=(obj)=>"object" === typeof obj ? Object.fromEntries(Object.entries(obj).map(([k,v])=>[k,cp(v)])) : obj myCopy = cp(MyObject)
spread
myCopy = {...MyObject}
obj.assign
myCopy = Object.assign({}, MyObject)
Structured Clone
myCopy = structuredClone(MyObject)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash cloneDeep
Json clone
Ramda clone
hand rolled
spread
obj.assign
Structured Clone

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmarking JSON and analyze each test case.

**Benchmark Definition**

The benchmark measures the performance of different methods for creating deep copies of objects in JavaScript. The `MyObject` is an object with nested properties, including strings and booleans. The goal is to compare various libraries and implementations for copying this object.

**Test Cases**

Here's a brief explanation of each test case:

1. **Lodash cloneDeep**: Uses Lodash's `cloneDeep` function to create a deep copy of the `MyObject`.
2. **Json clone**: Uses JSON's built-in stringification and parsing methods to create a copy of the `MyObject`. This method is not recommended for large objects, as it can lead to memory issues.
3. **Ramda clone**: Uses Ramda's `clone` function to create a deep copy of the `MyObject`.
4. **Hand rolled**: A custom implementation that creates a deep copy using recursion and object manipulation.
5. **Spread**: Uses the spread operator (`{...}`) to create a shallow copy of the `MyObject`. This method only works for objects with enumerable properties and does not work for non-enumerable ones.
6. **Obj.assign**: Uses the `Object.assign` method to create a deep copy of the `MyObject`.
7. **Structured Clone**: Uses the structured clone algorithm, which is a new feature in modern browsers (and Node.js) that allows for efficient cloning of objects.

**Pros and Cons**

Here's a brief summary of each implementation:

* **Lodash cloneDeep**: Pros: Efficient, accurate, and widely used. Cons: Requires an external library.
* **Json clone**: Pros: Simple, cons: Not recommended for large objects due to memory issues.
* **Ramda clone**: Pros: Efficient, accurate, and a popular choice among functional programmers. Cons: Requires an external library.
* **Hand rolled**: Pros: Customizable, can be optimized for specific use cases. Cons: More complex and prone to errors.
* **Spread**: Pros: Simple, cons: Only works for objects with enumerable properties and does not handle non-enumerable ones.
* **Obj.assign**: Pros: Efficient, accurate, and widely supported. Cons: Can lead to memory issues if used excessively.
* **Structured Clone**: Pros: Fast, efficient, and modern (new in browsers and Node.js). Cons: Limited support in older browsers or environments.

**Other Considerations**

When choosing a method for creating deep copies of objects, consider the following:

* **Memory usage**: If you're working with large objects, choose an implementation that is memory-efficient.
* **Performance**: Choose an implementation that balances performance and accuracy.
* **Library dependencies**: If you prefer to use external libraries, consider factors like licensing, documentation, and community support.
* **Browser or environment limitations**: Consider the specific browser or environment you're targeting and choose an implementation that works well in those conditions.

**Conclusion**

The choice of method for creating deep copies of objects depends on your specific needs, preferences, and constraints. Lodash's `cloneDeep` is a popular choice due to its efficiency and accuracy, while Ramda's `clone` offers similar benefits with more functional programming options. The hand rolled implementation provides customization but requires more expertise. The spread operator and `Object.assign` are simple solutions for specific use cases, while the structured clone algorithm is a modern, efficient solution that works in most browsers and environments.

Latest run results:

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

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 17_5_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 17 on iOS 17.5.1

View result in a separate tab

Test name	Executions per second
Lodash cloneDeep	2199883.2 Ops/sec
Json clone	1471718.4 Ops/sec
Ramda clone	1584661.2 Ops/sec
hand rolled	1399644.2 Ops/sec
spread	7473559.5 Ops/sec
obj.assign	4951818.0 Ops/sec
Structured Clone	769673.5 Ops/sec

Related benchmarks:

Lodash cloneDeep vs JSON Clone vs Ramda Clone vs hand rolled vs spread vs obj.assign vs structured clone (version: 0)

just benchmarking things

Comparing performance of: Lodash cloneDeep vs Json clone vs Ramda clone vs hand rolled vs spread vs obj.assign vs Structured Clone

Created: one year ago by: Guest

Jump to the latest result

Lodash cloneDeep

Json clone

Ramda clone

hand rolled

spread

obj.assign

Structured Clone

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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