Benchmark: Lodash cloneDeep vs JSON Clone vs Ramda Clone vs old school unroll vs hand rolled vs spread vs obj.assign

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 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)
og hand rolled (still recursive)
const cp_old=(obj)=>{ if ("object" !== typeof obj) { return obj } else { const entries = Object.entries(obj) for(let i = 0; i < entries.length; i++) { entries[i][2] = cp_old(entries[i][2]) } return Object.fromEntries(entries) } } myCopy = cp_old(MyObject)
manual stack
const cp_stack=(obj)=>{ if ("object" !== typeof obj) { return obj } else { const stack = [] let entries = Object.entries(obj) let i=0 stackloop: while(true) { for(; i < entries.length; i++) { const entry = entries[i][2] if ("object" !== typeof entry) continue else { stack.push([i,entries]) entries = Object.entries(entries[i][2]) i = 0 continue stackloop } } if (stack.length === 0) break [i, entries] = stack.pop() } return Object.fromEntries(entries) } } myCopy = cp_stack(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
og hand rolled (still recursive)
manual stack

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Measuring the performance of different approaches to deep cloning objects in JavaScript can be fascinating.

**Benchmark Overview**

The provided benchmark measures the execution speed of six different methods for creating a deep copy of an object:

1. Lodash `cloneDeep`
2. JSON clone (`JSON.parse(JSON.stringify())`)
3. Ramda `clone`
4. Hand-rolled (manual implementation)
5. Spread operator (`{...obj}`)
6. Object.assign with an empty object as the target (`Object.assign({}, obj)`)

**Method Overview**

Here's a brief explanation of each method:

1. **Lodash `cloneDeep`**: A popular utility library that provides a `cloneDeep` function for creating deep copies of objects.
2. **JSON clone**: Uses the `JSON.parse(JSON.stringify())` trick to create a deep copy by parsing a JSON representation of the object and then stringifying it again.
3. **Ramda `clone`**: A functional programming library that provides a `clone` function for creating deep copies of objects.
4. **Hand-rolled (manual implementation)**: A custom implementation using recursion or iteration to create a deep copy of an object.
5. **Spread operator (`{...obj}`)**: Creates a shallow copy by spreading the properties of the original object into a new object, but does not recursively clone nested objects.
6. **Object.assign with an empty object as the target (`Object.assign({}, obj)`)**: Creates a shallow copy by assigning the properties of the original object to a new object created using `Object.assign()`, but does not recursively clone nested objects.

**Performance Analysis**

The benchmark results show that:

* The spread operator and Object.assign with an empty object as the target are the slowest, likely due to their shallow copying nature.
* Lodash `cloneDeep` is faster than Ramda `clone`.
* JSON clone is relatively fast but may introduce performance issues if the input objects have complex structures.
* Hand-rolled implementations can be optimized for performance and might be competitive with Lodash `cloneDeep`.

Keep in mind that these results are specific to the Chrome 129 browser on a desktop platform. Performance differences may vary across different browsers, platforms, and use cases.

**Takeaways**

When choosing an approach for deep cloning objects in JavaScript:

* If you need a reliable and well-maintained solution, consider using Lodash `cloneDeep`.
* For small objects or simple cases, the spread operator or Object.assign might be sufficient.
* Be cautious when using JSON clone due to its potential performance issues.
* Hand-rolled implementations can be optimized for specific use cases, but may require more development effort.

Remember that deep cloning objects can have significant performance implications, especially for large datasets. It's essential to consider the trade-offs between performance, readability, and maintainability when selecting an approach.

Latest run results:

Run details: (Test run date: 7 days ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36

Browser/OS: Chrome 130 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Lodash cloneDeep	1394484.6 Ops/sec
Json clone	1189264.6 Ops/sec
Ramda clone	2168114.0 Ops/sec
hand rolled	1315591.9 Ops/sec
spread	6817921.0 Ops/sec
obj.assign	1658366.1 Ops/sec
og hand rolled (still recursive)	1924791.9 Ops/sec
manual stack	2256961.8 Ops/sec

Related benchmarks:

Lodash cloneDeep vs JSON Clone vs Ramda Clone vs old school unroll vs hand rolled vs spread vs obj.assign (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 og hand rolled (still recursive) vs manual stack

Created: 4 years ago by: Guest

Jump to the latest result

Lodash cloneDeep

Json clone

Ramda clone

hand rolled

spread

obj.assign

og hand rolled (still recursive)

manual stack

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