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

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 26 days ago):

LLMs can make mistakes. Check important info.

The provided benchmark measures the performance of four different methods for cloning and manipulating JavaScript objects: Lodash's `cloneDeep`, JSON's built-in `JSON.parse` and `JSON.stringify` methods, Ramda's `clone` function, and Pvorb's `clone` function.

Here's a brief overview of each method:

1. **Lodash cloneDeep**: This function creates a deep copy of the input object, which means it recursively clones all nested objects and arrays. It's designed to handle complex data structures.
2. **JSON Clone**: The JSON `parse` and `stringify` methods can be used together to create a deep copy of an object. However, this method is not as efficient as Lodash's `cloneDeep`, especially for large or deeply nested objects.
3. **Ramda clone**: Ramda's `clone` function creates a shallow copy of the input object, which means it only clones the top-level properties and does not recursively clone nested objects or arrays. However, this method can be faster than Lodash's `cloneDeep` for simple data structures.
4. **Pvorb Clone**: Pvorb's `clone` function is similar to Ramda's `clone`, but its implementation is optimized for performance.

**Options Compared:**

The benchmark compares the following options:

* Deep cloning (Lodash, Ramda)
* Shallow cloning (Ramda)
* Using JSON's built-in methods (JSON Clone)

**Pros and Cons:**

* **Deep Cloning (Lodash, Ramda)**:
	+ Pros:
		- Handles complex data structures
		- Recursively clones nested objects and arrays
	+ Cons:
		- Can be slower for large or simple data structures
		- May consume more memory due to recursive cloning
* **Shallow Cloning (Ramda)**:
	+ Pros:
		- Faster than deep cloning for simple data structures
		- Consumes less memory
	+ Cons:
		- Does not handle complex data structures
		- Recursively clones only top-level properties
* **JSON Clone**:
	+ Pros:
		- Fast and lightweight
	+ Cons:
		- Not designed to handle complex data structures
		- May not be suitable for large or deeply nested objects

**Library and Purpose:**

1. **Lodash**: A popular JavaScript utility library that provides a wide range of functions, including `cloneDeep`.
2. **Ramda**: A functional programming library that provides several utility functions, including `clone`.
3. **JSON**: The JSON (JavaScript Object Notation) standard for exchanging data between systems.

**Special JS Features/Syntax:**

None mentioned in the provided benchmark definition.

**Other Alternatives:**

1. **Underscore.js**: Another popular JavaScript utility library that provides a similar function to Lodash's `cloneDeep`.
2. **Immutable.js**: A library that provides immutable data structures and functions, including `clone`.

When choosing a cloning method, consider the complexity of your data structure, performance requirements, and memory constraints. If you need to handle complex or deeply nested objects, deep cloning (Lodash or Ramda) might be the best choice. For simple data structures, shallow cloning (Ramda) could be faster and more memory-efficient.

Latest run results:

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

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

Browser/OS: Chrome 80 on Mac OS X 10.14.3

View result in a separate tab

Test name	Executions per second
Lodash cloneDeep	476224.1 Ops/sec
Json clone	237712.9 Ops/sec
Ramda clone	671441.9 Ops/sec
Pvorb Clone	411623.1 Ops/sec

Related benchmarks:

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

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

Created: 5 years ago by: Registered User

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 26 days ago):