Benchmark: Lodash cloneDeep vs JSON Clone vs Ramda Clone vs Pvorb Clone - 2

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);
Pvorb Clone
myCopy = clone(MyObject, false);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash cloneDeep
Json clone
Ramda clone
Pvorb Clone

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 25 days ago):

LLMs can make mistakes. Check important info.

Let's break down the benchmark and its components.

**Benchmark Overview**

The benchmark compares four JavaScript functions: `cloneDeep` from Lodash, `JSON.parse(JSON.stringify())`, `R.clone()` from Ramda, and `clone()` from Pvorb. The test creates a deep copy of an object using each function and measures their performance.

**Script Preparation Code**

The script preparation code defines an object `MyObject` with nested properties, including a string property `jayson`. This object is used to create copies of itself using the different functions being compared.

**Html Preparation Code**

The HTML preparation code includes scripts from three external libraries: Lodash, Ramda, and Pvorb. These libraries are used by the individual test cases.

**Individual Test Cases**

Each test case uses a different function to create a copy of `MyObject`:

1. **Lodash cloneDeep**: `myCopy = _.cloneDeep(MyObject);`
	* The Lodash library provides a `cloneDeep()` function that creates a deep copy of an object.
	* Pros: Efficient, flexible, and widely used.
	* Cons: Adds external dependency (Lodash).
2. **JSON Clone**: `myCopy = JSON.parse(JSON.stringify(MyObject));`
	* This method uses the `JSON` object to serialize and deserialize `MyObject`, creating a copy of it.
	* Pros: Lightweight, easy to implement.
	* Cons: Not efficient for large objects or complex data structures.
3. **Ramda clone**: `myCopy = R.clone(MyObject);`
	* The Ramda library provides a `clone()` function that creates a deep copy of an object.
	* Pros: Efficient, flexible, and widely used (like Lodash).
	* Cons: Adds external dependency (Ramda).
4. **Pvorb Clone**: `myCopy = clone(MyObject, false);`
	* The Pvorb library provides a `clone()` function that creates a deep copy of an object.
	* Pros: Lightweight, easy to implement.
	* Cons: Less popular than Lodash or Ramda.

**Other Considerations**

* **Performance**: The benchmark measures the execution speed of each function. However, other factors like memory usage and cache efficiency might also be important in certain scenarios.
* **Memory Safety**: When cloning objects, it's essential to consider memory safety to prevent issues like data corruption or crashes due to unexpected modifications.

**Alternatives**

If you don't want to use external libraries like Lodash, Ramda, or Pvorb, you can implement your own deep copy function using techniques like:

* Recursive iteration over object properties
* Using `Object.assign()` and creating a new object with shallow copies of each property
* Utilizing bitwise operators (e.g., `|=`) to create a new object with the same prototype chain as the original

Keep in mind that these alternatives might not be as efficient or flexible as using established libraries like Lodash or Ramda.

In summary, the benchmark compares four JavaScript functions for creating deep copies of objects. Each function has its pros and cons, and understanding these will help you choose the most suitable approach for your specific use case.

Latest run results:

Run details: (Test run date: 2 years ago)

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

Browser/OS: Chrome 95 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Lodash cloneDeep	678664.2 Ops/sec
Json clone	360668.8 Ops/sec
Ramda clone	945831.9 Ops/sec
Pvorb Clone	590136.6 Ops/sec

Related benchmarks:

Lodash cloneDeep vs JSON Clone vs Ramda Clone vs Pvorb Clone - 2 (version: 0)

Comparing performance of: Lodash cloneDeep vs Json clone vs Ramda clone vs Pvorb Clone

Created: 2 years ago by: Guest

Jump to the latest result

Lodash cloneDeep

Json clone

Ramda clone

Pvorb Clone

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 25 days ago):