Benchmark: lodash cloneDeep vs. JSON.parse(JSON.stringify()) vs. fastest-json-copy

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.21/lodash.min.js'></script>
<script src='https://cdn.jsdelivr.net/npm/jsondiffpatch@0.4.1/dist/jsondiffpatch.umd.min.js'></script>
<script src='https://cdn.jsdelivr.net/npm/rfdc@1.3.0'></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;

var jsondiffpatchClone = jsondiffpatch.clone;
var rfdcClone = rfdc();

///////////////////////////////////////////////////////////////////
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;
  }
//////////////////////////////////////////////////////////////////
// Use https://www.npmjs.com/package/fastest-json-copy
// Instead of the code below! It is the same thing, just minified.
var isArray=Array.isArray;function fastestJsonCopy(r){if(!r)return r;if(isArray(r)){for(var e=[],o=r.length,t=0;t<o;t++)e.push(fastestJsonCopy(r[t]));return e}if("object"==typeof r){var y=Object.keys(r),a=(o=y.length,{});for(t=0;t<o;t++){var c=y[t];a[c]=fastestJsonCopy(r[c])}return a}return r}

Tests:

lodash cloneDeep
myCopy = _.cloneDeep(MyObject);
JSON.parse(JSON.stringify())
myCopy = JSON.parse(JSON.stringify(MyObject));
recursiveDeepCopy
myCopy = recursiveDeepCopy(MyObject);
fastest-json-copy npm package
myCopy = fastestJsonCopy(MyObject);
jsondiffpatch.clone()
myCopy = jsondiffpatchClone(MyObject);
rfdc
myCopy = rfdcClone(MyObject);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash cloneDeep
JSON.parse(JSON.stringify())
recursiveDeepCopy
fastest-json-copy npm package
jsondiffpatch.clone()
rfdc

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 5 days ago)

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

Browser/OS: Opera 115 on Linux

View result in a separate tab

Test name	Executions per second
lodash cloneDeep	731345.6 Ops/sec
JSON.parse(JSON.stringify())	647760.5 Ops/sec
recursiveDeepCopy	2623281.0 Ops/sec
fastest-json-copy npm package	2284284.0 Ops/sec
jsondiffpatch.clone()	2629170.5 Ops/sec
rfdc	2744523.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation of the provided benchmark.

**Benchmark Overview**

The benchmark measures the performance of different methods for creating a deep copy of an object in JavaScript. The test case uses a small object with various data types (number, boolean, and nested object) to simulate real-world scenarios.

**Methods Compared**

1. **`lodash.cloneDeep()`**: A popular library function that creates a deep clone of an object.
2. **`JSON.parse(JSON.stringify())`**: A built-in JavaScript method that converts a value to a JSON string and then parses it back into an object, effectively creating a deep copy.
3. **`fastest-json-copy` (npm package)**: A lightweight library function specifically designed for fast JSON copying.
4. **`jsondiffpatch.clone()`**: A method from the `jsondiffpatch` library that creates a deep clone of an object based on the differences between the original and cloned objects.
5. **`rfdc()` (recursive deep copy)**: A custom implementation of a recursive deep copy function.

**Options Compared**

The options compared are:

* Deep cloning: creating a new, independent copy of the entire object graph.
* Shallow copying: creating a new copy of only the top-level properties of the object.

**Pros and Cons of Each Approach**

1. **`lodash.cloneDeep()`**:
	* Pros: widely used, well-maintained, and efficient.
	* Cons: adds extra dependencies (Lodash), can be slower for very large objects due to recursive function calls.
2. **`JSON.parse(JSON.stringify())`**:
	* Pros: built-in, fast, and easy to understand.
	* Cons: limited support for custom object constructors, may not work with complex data structures like arrays or sets.
3. **`fastest-json-copy` (npm package)**:
	* Pros: lightweight, fast, and efficient.
	* Cons: may have compatibility issues with older browsers or Node versions.
4. **`jsondiffpatch.clone()`**:
	* Pros: tailored for objects with many small changes, efficient for incremental updates.
	* Cons: may be slower than other methods for very large objects due to the complexity of calculating differences.
5. **`rfdc()`**:
	* Pros: custom implementation can optimize performance for specific use cases.
	* Cons: requires manual management of memory and recursion, potentially error-prone.

**Benchmark Results**

The provided benchmark results show the execution rate (executions per second) for each method, which indicates the relative performance of each approach. The top performers are:

1. `fastest-json-copy` (npm package)
2. `rfdc()`
3. `jsondiffpatch.clone()`

Related benchmarks:

lodash cloneDeep vs. JSON.parse(JSON.stringify()) vs. fastest-json-copy | On a Small Object (version: 3)

Comparing performance of: lodash cloneDeep vs JSON.parse(JSON.stringify()) vs recursiveDeepCopy vs fastest-json-copy npm package vs jsondiffpatch.clone() vs rfdc

Created: 3 years ago by: Registered User

Jump to the latest result

lodash cloneDeep

JSON.parse(JSON.stringify())

recursiveDeepCopy

fastest-json-copy npm package

jsondiffpatch.clone()

rfdc

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):