Benchmark: Lodash cloneDeep vs returning new instance of object

Lodash cloneDeep vs returning new instance of object (version: 0)

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...' } };

Comparing performance of: Lodash cloneDeep vs Returning new object

Created: 3 years ago by: Guest

Jump to the latest result

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.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...'
  }
};

function getMyObject() {
	return {
  		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);
Returning new object
myCopy = getMyObject();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash cloneDeep
Returning new object

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.77 Safari/537.36

Browser/OS: Chrome 91 on Windows

View result in a separate tab

Test name	Executions per second
Lodash cloneDeep	355970.9 Ops/sec
Returning new object	3234748.8 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark definition and explain what's being tested, compared, and their pros and cons.

**Benchmark Definition:**

The benchmark compares two approaches to create a copy of an object:

1. **Lodash cloneDeep**: Uses the Lodash library to create a deep copy of the object.
2. **Returning new instance of object**: Creates a new object manually by returning an empty object (`{}`) and then assigning properties from the original object.

**Options Compared:**

The two options are compared in terms of their performance, which is measured in executions per second.

**Pros and Cons:**

* **Lodash cloneDeep**:
	+ Pros:
		- Creates a deep copy of the object, which can be useful for complex data structures.
		- Is implemented in JavaScript, making it easy to use and understand.
	+ Cons:
		- Requires an external library (Lodash), which might increase the benchmark's overhead.
* **Returning new instance of object**:
	+ Pros:
		- Does not require an external library, reducing overhead.
		- Can be faster since it doesn't involve a function call or dependency on Lodash.
	+ Cons:
		- Requires manual implementation, which can lead to errors if not done correctly.

**Library:**

In this benchmark, the `lodash` library is used. Lodash is a popular JavaScript utility library that provides functions for various tasks, such as array manipulation, object creation, and more. The `cloneDeep` function in particular creates a deep copy of an object, which means it recursively clones all nested properties.

**Special JS Feature/Syntax:**

This benchmark does not use any special JavaScript features or syntax beyond the standard ECMAScript syntax. It only relies on the basic language constructs and libraries (in this case, Lodash).

**Alternatives:**

If you wanted to implement a custom copy function without using an external library like Lodash, you could use a recursive approach similar to `cloneDeep`. However, this would likely involve more code and potentially lead to errors if not implemented correctly.

Another alternative is using the `Object.assign()` method or `Spread Operator` (in modern JavaScript) to create a shallow copy of an object. However, these methods do not support deep copying and would require additional handling for nested objects.

Overall, this benchmark provides a simple yet informative comparison between two approaches to creating a copy of an object in JavaScript, highlighting the trade-offs between using an external library like Lodash versus implementing a custom solution.

Related benchmarks: