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)

Historical Performance Data aggregated from 9 community runs

Desktop Results:

Chrome 9 runs

spread

8.9M/s

obj.assign

3.1M/s

Ramda clone

2.2M/s

manual stack

1.8M/s

og hand rolled (still recursive)

1.6M/s

Lodash cloneDeep

1.4M/s

Json clone

1.1M/s

hand rolled

1.1M/s

Fastest: spread (8.5x faster)

View exact numbers

✓ spread: 8,941,401 ops/sec
• obj.assign: 3,086,149 ops/sec
• Ramda clone: 2,168,114 ops/sec
• manual stack: 1,848,455 ops/sec
• og hand rolled (still recursive): 1,636,745 ops/sec
• Lodash cloneDeep: 1,394,485 ops/sec
• Json clone: 1,112,394 ops/sec
• hand rolled: 1,052,149 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

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

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 136 on Windows

View result in a separate tab

spread

13.2M/s

obj.assign

12.7M/s

manual stack

5.1M/s

og hand rolled (still recursive)

4.0M/s

Ramda clone

3.3M/s

hand rolled

3.2M/s

Lodash cloneDeep

1.8M/s

Json clone

1.5M/s

View exact numbers

Test name	Executions per second
✓ spread	13,207,563 Ops/sec
obj.assign	12,699,029 Ops/sec
manual stack	5,144,866 Ops/sec
og hand rolled (still recursive)	4,047,103 Ops/sec
Ramda clone	3,287,766 Ops/sec
hand rolled	3,193,861 Ops/sec
Lodash cloneDeep	1,789,795 Ops/sec
Json clone	1,534,792 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year 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.

Lodash cloneDeep vs JSON Clone vs Ramda Clone vs old school unroll vs hand rolled vs spread vs obj.assign (version: 0) Benchmark.js

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: 6 years ago by: Guest

Go to the latest result

Lodash cloneDeep

Json clone

Ramda clone

hand rolled

spread

obj.assign

og hand rolled (still recursive)

manual stack

Historical Performance Data aggregated from 9 community runs

Desktop Results:

Chrome 9 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Lodash cloneDeep vs JSON Clone vs Ramda Clone vs old school unroll vs hand rolled vs spread vs obj.assign (version: 0) Benchmark.js

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: 6 years ago by: Guest

Go to the latest result

Lodash cloneDeep

Json clone

Ramda clone

hand rolled

spread

obj.assign

og hand rolled (still recursive)

manual stack

Historical Performance Data aggregated from 9 community runs

Desktop Results:

Chrome 9 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

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`