Benchmark: lodash/cloneDeep vs. JSON.parse(JSON.stringify())

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.21/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...'
  }
};

Tests:

lodash cloneDeep
myCopy = _.cloneDeep(MyObject);
JSON.parse(JSON.stringify())
myCopy = JSON.parse(JSON.stringify(MyObject));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash cloneDeep
JSON.parse(JSON.stringify())

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Mobile Safari/537.36

Browser/OS: Chrome Mobile 115 on Android

View result in a separate tab

Test name	Executions per second
lodash cloneDeep	349532.4 Ops/sec
JSON.parse(JSON.stringify())	169686.5 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 benchmark and its results.

**What is being tested?**

The provided JSON represents a JavaScript microbenchmarking test created on MeasureThat.net. The test compares two methods for creating a deep copy of an object:

1. `_.cloneDeep` from the Lodash library.
2. `JSON.parse(JSON.stringify())`.

These two approaches are compared to determine which one is faster and more efficient.

**Options being compared:**

The two options being tested are:

A) Using `_.cloneDeep` from the Lodash library, which is a utility function that creates a deep copy of an object.
B) Using `JSON.parse(JSON.stringify())`, which parses a JSON string and returns the equivalent JavaScript object. However, this approach does not create a true copy of the object; it only recreates the object with the same properties.

**Pros and Cons:**

**_.cloneDeep (Lodash)**

Pros:

* Creates a true deep copy of an object.
* Handles complex object structures, such as arrays within objects.
* Is a well-maintained and widely used library function.

Cons:

* May have slower performance compared to other approaches due to its overhead from the Lodash library.
* Requires including additional JavaScript code (the Lodash library).

**JSON.parse(JSON.stringify())**

Pros:

* Lightweight and doesn't require any additional library code.
* Can be faster for simple objects or cases where the object structure is not complex.

Cons:

* Does not create a true copy of the object, only recreates it with the same properties. This can lead to issues if the original object changes after creation.
* May not handle certain data types or structures correctly (e.g., dates, functions, etc.).

**Other considerations:**

* The Lodash library provides many other useful utility functions beyond `cloneDeep`.
* Using `JSON.parse(JSON.stringify())` assumes that the input object is in a format that can be safely parsed by JSON.

**Library and its purpose:**

The Lodash library (specifically, the `cloneDeep` function) is a popular JavaScript utility library that provides various functions for working with data structures, such as arrays, objects, and more. The `cloneDeep` function creates a deep copy of an object, which can be useful in many scenarios where you need to work with independent copies of complex data.

**Special JS feature or syntax:**

There are no special JavaScript features or syntax used in this benchmark. Both methods rely on standard JavaScript language constructs and libraries (Lodash).

Now that we've analyzed the benchmark, let's take a look at some alternative approaches for creating deep copies of objects:

* **Array.prototype.slice()**: Creates a shallow copy of an array.
* **Object.assign()**: Creates a shallow copy of an object.
* **structuredClone()**: A relatively new JavaScript feature (introduced in ECMAScript 2022) that can create a deep clone of objects.

Related benchmarks:

lodash/cloneDeep vs. JSON.parse(JSON.stringify()) (version: 0)

Comparing performance of: lodash cloneDeep vs JSON.parse(JSON.stringify())

Created: one year ago by: Registered User

Jump to the latest result

lodash cloneDeep

JSON.parse(JSON.stringify())

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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