Benchmark: Lodash cloneDeep vs JSON Clone vs Ramda Clone vs old school ugly

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)
loop not map (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)
original gangster
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)
uglified
const cp_uglify=e=>{if("object"!=typeof e)return e;{const t=[];let n=Object.entries(e),o=0;e:for(;;){for(;o<n.length;o++){if("object"==typeof n[o][2]){t.push([o,n]),n=Object.entries(n[o][2]),o=0;continue e}}if(0===t.length)break;[o,n]=t.pop()}return Object.fromEntries(n)}}; myCopy = cp_uglify(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
loop not map (still recursive)
original gangster
uglified

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and its test cases.

**What is being tested?**

The benchmark tests four different methods for creating a deep copy of an object in JavaScript:

1. **Lodash `cloneDeep`**: A function from the Lodash library that creates a deep copy of an object.
2. **JSON Clone**: A built-in JavaScript function that converts an object to a JSON string and then parses it back into an object, effectively creating a deep copy.
3. **Ramda `clone`**: A function from the Ramda library that creates a deep copy of an object.
4. **Hand-rolled** (also known as "ugly"): A custom implementation of a deep copy using a recursive loop.
5. **Loop not map (still recursive)**: Another custom implementation of a deep copy, similar to the hand-rolled version, but with some minor differences.

The benchmark also includes two additional test cases:

6. **Original gangster**: The same hand-rolled implementation as the "Hand-rolled" test case.
7. **Uglified**: A slightly modified version of the hand-rolled implementation.

**Key differences between the methods**

Here's a brief summary of each method:

* **Lodash `cloneDeep`**: Uses a recursive loop to traverse the object graph and create a new copy. It handles complex data structures, such as arrays and objects, efficiently.
* **JSON Clone**: Converts the object to a JSON string and then parses it back into an object. This method can lead to performance issues due to the overhead of serializing and deserializing the object.
* **Ramda `clone`**: Uses a similar recursive loop approach as Lodash `cloneDeep`, but with some optimizations for performance.
* **Hand-rolled** (Loop not map): A custom implementation that uses a recursive loop to traverse the object graph. This method can be prone to errors and may not handle all edge cases correctly.
* **Loop not map (still recursive)**: Another custom implementation with minor differences from the hand-rolled version.

The "Original gangster" test case is simply an alias for the "Hand-rolled" test case, while the "Uglified" test case is a modified version of the same hand-rolled implementation.

**Performance implications**

Based on the benchmark results, it appears that:

* Lodash `cloneDeep` and Ramda `clone` are relatively fast and efficient methods.
* The custom implementations (Hand-rolled and Loop not map) are significantly slower than the library-based approaches.
* JSON Clone is the slowest method due to its overhead in serializing and deserializing the object.

Keep in mind that these results may vary depending on the specific use case, input data, and other factors. It's always a good idea to test different methods and optimize for performance according to your specific needs.

Related benchmarks:

Lodash cloneDeep vs JSON Clone vs Ramda Clone vs old school ugly (version: 0)

just benchmarking things

Comparing performance of: Lodash cloneDeep vs Json clone vs Ramda clone vs hand rolled vs loop not map (still recursive) vs original gangster vs uglified

Created: 6 years ago by: Guest

Jump to the latest result

Lodash cloneDeep

Json clone

Ramda clone

hand rolled

loop not map (still recursive)

original gangster

uglified

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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