Benchmark: lodash clonedeep vs json.parse(stringify()) vs recursivecopy vs structuredClone 1234

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...'
  }
};

var myCopy = null;

function recursiveDeepCopy(o) {
    var newO,
      i;
  
    if (typeof o !== 'object') {
      return o;
    }
    if (!o) {
      return o;
    }
  
    if ('[object Array]' === Object.prototype.toString.apply(o)) {
      newO = [];
      for (i = 0; i < o.length; i += 1) {
        newO[i] = recursiveDeepCopy(o[i]);
      }
      return newO;
    }
  
    newO = {};
    for (i in o) {
      if (o.hasOwnProperty(i)) {
        newO[i] = recursiveDeepCopy(o[i]);
      }
    }
    return newO;
  }

Tests:

Lodash CloneDeep
myCopy = _.cloneDeep(MyObject);
Json Clone
myCopy = JSON.parse(JSON.stringify(MyObject));
recursiveDeepCopy
myCopy = recursiveDeepCopy(MyObject);
structuredClone
myCopy = structuredClone(MyObject);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash CloneDeep
Json Clone
recursiveDeepCopy
structuredClone

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark and explain what's being tested, compared, and the pros/cons of each approach.

**Benchmark Overview**

The test suite is designed to compare the performance of four different methods for creating a deep copy of an object in JavaScript:

1. `lodash.cloneDeep()`
2. `JSON.parse(JSON.stringify())`
3. `recursiveDeepCopy()` (a custom implementation)
4. `structuredClone()` (a new method introduced in ECMAScript 2020)

**Comparison of Methods**

Each test case uses a similar input object, `MyObject`, which contains nested objects and arrays.

1. **`lodash.cloneDeep()`**: This method is part of the popular JavaScript utility library, Lodash. It recursively creates a deep copy of the original object.
2. **`JSON.parse(JSON.stringify())`**: This method serializes the input object to a JSON string, then parses it back into an object. While this works for simple objects, it can lead to issues with circular references and other complex data structures.
3. **`recursiveDeepCopy()`**: This is a custom implementation of a recursive deep copy function. It handles arrays and objects with nested properties correctly but may be less efficient than the others due to its bespoke nature.
4. **`structuredClone()`**: This method was introduced in ECMAScript 2020 as a new way to create deep copies of objects. It's designed to be more efficient and reliable than traditional methods like `JSON.parse(JSON.stringify())`.

**Pros/Cons of Each Approach**

1. **`lodash.cloneDeep()`**
	* Pros: Robust, widely supported, and well-tested.
	* Cons: Requires an additional library dependency.
2. **`JSON.parse(JSON.stringify())`**
	* Pros: Simple to implement, works for simple objects.
	* Cons: Fails with circular references, can lead to incorrect results.
3. **`recursiveDeepCopy()`**
	* Pros: Custom implementation allows for fine-tuning performance.
	* Cons: May be less efficient than others, requires bespoke maintenance.
4. **`structuredClone()`**
	* Pros: New method designed for deep copying, more efficient and reliable.
	* Cons: New feature, may not be supported in older browsers or environments.

**Library Used**

The `lodash.cloneDeep()` method is part of the Lodash library, which provides a wide range of utility functions for JavaScript development. Lodash is widely used and well-maintained, making it a popular choice for many developers.

**Special JS Feature/Syntax**

None mentioned in this benchmark.

**Alternatives**

If you need to create deep copies of objects in JavaScript, other alternatives to `structuredClone()` include:

* Using `JSON.parse(JSON.stringify())` (with caution and awareness of its limitations).
* Implementing a custom recursive deep copy function like `recursiveDeepCopy()`.
* Using other libraries or modules that provide similar functionality.

Keep in mind that the choice of method depends on your specific use case, performance requirements, and personal preference.

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36

Browser/OS: Chrome 113 on Linux

View result in a separate tab

Test name	Executions per second
Lodash CloneDeep	635433.2 Ops/sec
Json Clone	381250.0 Ops/sec
recursiveDeepCopy	905076.6 Ops/sec
structuredClone	239282.5 Ops/sec

Related benchmarks:

lodash clonedeep vs json.parse(stringify()) vs recursivecopy vs structuredClone 1234 (version: 0)

Comparing performance of: Lodash CloneDeep vs Json Clone vs recursiveDeepCopy vs structuredClone

Created: one year ago by: Guest

Jump to the latest result

Lodash CloneDeep

Json Clone

recursiveDeepCopy

structuredClone

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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