Benchmark: Lodash cloneDeep vs JSON Clone vs Ramda Clone 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 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);
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)

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

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 136 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Lodash cloneDeep	2120646.5 Ops/sec
Json clone	1913437.1 Ops/sec
Ramda clone	3918198.5 Ops/sec
hand rolled	3123059.0 Ops/sec
spread	14967252.0 Ops/sec
obj.assign	14679841.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the benchmark and explore what's being tested, the pros and cons of each approach, and other considerations.

**Benchmark Overview**

The benchmark is designed to compare the performance of different methods for creating a deep copy of an object: Lodash's `cloneDeep`, JSON's clone method, Ramda's `clone`, a hand-rolled implementation, and two built-in JavaScript methods: spread (`{...}`) and `Object.assign()`.

**Test Cases**

Each test case is defined by a JavaScript statement that creates a deep copy of the `MyObject` variable. The statements are:

1. Lodash cloneDeep: `myCopy = _.cloneDeep(MyObject)`
2. JSON clone: `myCopy = JSON.parse(JSON.stringify(MyObject))`
3. Ramda clone: `myCopy = R.clone(MyObject)`
4. Hand-rolled implementation: `const cp=(obj)=>"object" === typeof obj ? Object.fromEntries(Object.entries(obj).map(([k,v])=>[k,cp(v)])) : obj; myCopy = cp(MyObject)`
5. Spread operator: `myCopy = {...MyObject}`
6. `Object.assign()` method: `myCopy = Object.assign({}, MyObject)`

**Library and Purpose**

1. Lodash: A utility library that provides functional programming helpers, including the `cloneDeep` function.
2. Ramda: A functional programming library that provides a small set of functions for working with data, including `clone`.
3. JSON: The JavaScript object notation standard, which provides methods for serializing and deserializing objects.

**Special JS Feature or Syntax**

None mentioned explicitly in the benchmark definition, but it's worth noting that Ramda uses a functional programming style, whereas Lodash and the hand-rolled implementation use imperative programming styles.

**Pros and Cons of Each Approach**

1. **Lodash cloneDeep**: Pros:
	* Well-tested and widely used function.
	* Supports nested objects and arrays.
Cons:
	* May be overkill for simple copying needs.
2. **JSON clone**: Pros:
	+ Lightweight and easy to implement.
Cons:
	+ Not designed for deep copying; can create shallow copies.
3. **Ramda clone**: Pros:
	+ Functional programming style, which can be more concise.
Cons:
	+ May not be as efficient as imperative approaches.
4. **Hand-rolled implementation**: Pros:
	+ Customizable and easy to understand.
Cons:
	+ Requires manual handling of nested objects and arrays.
5. **Spread operator** (`{...}`): Pros:
	+ Simple and lightweight.
Cons:
	+ Only works for copying shallow objects (i.e., those with no nested objects).
6. `Object.assign()` method: Pros:
	+ Fast and efficient.
Cons:
	+ May not handle circular references correctly.

**Other Considerations**

* The benchmark only tests the copying performance, ignoring other aspects of object manipulation, such as modification or updates.
* The use of a pre-defined `MyObject` variable ensures that all test cases are testing the same input data.
* The test results can help developers choose the best approach for their specific needs.

**Alternatives**

Other methods for creating deep copies include:

1. Using `Array.prototype.slice()` and `Object.assign()`
2. Implementing a custom copying function using recursion or iteration
3. Utilizing libraries like Immutable.js or Redux's `immer` module

Each of these alternatives has its own trade-offs, pros, and cons, which may not be immediately apparent without testing.

Related benchmarks:

Lodash cloneDeep vs JSON Clone vs Ramda Clone vs hand rolled vs spread vs obj.assign (version: 0)

just benchmarking things

Comparing performance of: Lodash cloneDeep vs Json clone vs Ramda clone vs hand rolled vs spread vs obj.assign

Created: 6 years ago by: Guest

Jump to the latest result

Lodash cloneDeep

Json clone

Ramda clone

hand rolled

spread

obj.assign

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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