Benchmark: Deep Clone Performance - JSON vs Lodash vs Ramda vs Native

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 obj = {a: "hello", c: "test", po: 33, arr: [1, 2, 3, 4], anotherObj: {a: 33, str: "whazzup"}};

var myCopy = null;

Tests:

JSON Stringfy
myCopy = JSON.parse(JSON.stringify(obj));
Lodash cloneDeep
myCopy = _.cloneDeep(obj);
Ramda Copy
myCopy = R.clone(obj);
Recursive Copy
var deepCopy = function(obj) { var out = Array.isArray(obj) ? [] : {}; for (var key in obj) { var v = obj[key]; out[key] = (typeof v === 'object') ? deepCopy(v) : v; } return out; }; myCopy = deepCopy(obj);
Recursive Copy Distinct
var deepCopy = function(block) { var out = null; if (Array.isArray(block)) { out = []; for (var index = 0; index < block.length; ++index) { var subArray = block[index]; out.push((typeof subArray === 'object') ? deepCopy(subArray) : subArray); } } else { out = {}; for (var key in block) { var subObject = block[key]; out[key] = (typeof subObject === 'object') ? deepCopy(subObject) : subObject; } } return out; }; myCopy = deepCopy(obj);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
JSON Stringfy
Lodash cloneDeep
Ramda Copy
Recursive Copy
Recursive Copy Distinct

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 benchmark JSON and explain what is being tested.

**Benchmark Definition**

The benchmark is designed to measure the performance of different methods for creating a deep copy of an object. The test cases are:

1. `JSON Stringfy`: Creating a deep copy using `JSON.stringify` and then parsing the result back into a JavaScript object.
2. `Lodash cloneDeep`: Using the `cloneDeep` function from the Lodash library to create a deep copy of the object.
3. `Ramda Copy`: Using the `R.clone` function from the Ramda library to create a deep copy of the object.
4. `Recursive Copy`: Creating a custom recursive function to create a deep copy of the object.
5. `Recursive Copy Distinct`: A variant of the previous test case with some modifications.

**Options Compared**

The benchmark is comparing five different approaches:

1. `JSON Stringfy`
2. `Lodash cloneDeep`
3. `Ramda Copy`
4. `Recursive Copy` (the custom function)
5. `Recursive Copy Distinct` (a variant of the previous test case)

**Pros and Cons of Each Approach**

Here's a brief summary of the pros and cons of each approach:

1. **JSON Stringfy**:
	* Pros: Simple, widely supported.
	* Cons: Can be slow for large objects, may not work correctly with circular references.
2. **Lodash cloneDeep**:
	* Pros: Efficient, well-tested, and widely used.
	* Cons: Requires additional dependency (Lodash library).
3. **Ramda Copy**:
	* Pros: Lightweight, efficient, and modern.
	* Cons: May require some familiarity with Ramda's API.
4. **Recursive Copy**:
	* Pros: Customizable, easy to understand.
	* Cons: Can be slow for large objects, prone to stack overflows if not implemented carefully.
5. **Recursive Copy Distinct**:
	* Pros: Variant of the previous test case with some modifications (not specified in the benchmark).
	* Cons: Same pros and cons as Recursive Copy.

**Libraries and Special Features**

The following libraries are used:

1. Lodash: A utility library that provides the `cloneDeep` function.
2. Ramda: A functional programming library that provides the `R.clone` function.

There are no special JavaScript features or syntaxes mentioned in the benchmark.

**Alternatives**

Other alternatives for creating deep copies could include:

1. Using a custom implementation of a copy function, like the Recursive Copy test case.
2. Using a third-party library like Underscore.js or Mocha.
3. Using a framework-specific built-in function (e.g., React's `useMemo` hook).
4. Using a simple object cloning approach with shallow copies for certain properties.

However, it's worth noting that the Lodash `cloneDeep` and Ramda `R.clone` functions are widely used and well-tested solutions for creating deep copies in JavaScript.

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/119.0.0.0 Safari/537.36

Browser/OS: Chrome 119 on Windows

View result in a separate tab

Test name	Executions per second
JSON Stringfy	1049949.1 Ops/sec
Lodash cloneDeep	965556.3 Ops/sec
Ramda Copy	1111835.5 Ops/sec
Recursive Copy	1462616.4 Ops/sec
Recursive Copy Distinct	2770265.0 Ops/sec

Related benchmarks:

Deep Clone Performance - JSON vs Lodash vs Ramda vs Native (version: 0)

Comparing performance of: JSON Stringfy vs Lodash cloneDeep vs Ramda Copy vs Recursive Copy vs Recursive Copy Distinct

Created: 6 years ago by: Registered User

Jump to the latest result

JSON Stringfy

Lodash cloneDeep

Ramda Copy

Recursive Copy

Recursive Copy Distinct

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