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>

AخA
 
<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}

​x
 
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);
myCopy = _.cloneDeep(MyObject);
JSON.parse(JSON.stringify())
myCopy = JSON.parse(JSON.stringify(MyObject));
myCopy = JSON.parse(JSON.stringify(MyObject));
recursiveDeepCopy
myCopy = recursiveDeepCopy(MyObject);
myCopy = recursiveDeepCopy(MyObject);
fastest-json-copy npm package
myCopy = fastestJsonCopy(MyObject);
myCopy = fastestJsonCopy(MyObject);
jsondiffpatch.clone()
myCopy = jsondiffpatchClone(MyObject);
myCopy = jsondiffpatchClone(MyObject);
rfdc
myCopy = rfdcClone(MyObject);
myCopy = rfdcClone(MyObject);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

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: 2 days ago)

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

Browser/OS: Opera 117 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
lodash cloneDeep	1883537.2 Ops/sec
JSON.parse(JSON.stringify())	1575473.8 Ops/sec
recursiveDeepCopy	5888464.0 Ops/sec
fastest-json-copy npm package	5188675.0 Ops/sec
jsondiffpatch.clone()	5843849.5 Ops/sec
rfdc	6499450.0 Ops/sec

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

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

lodash.cloneDeep(): A popular library function that creates a deep clone of an object.
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.
fastest-json-copy (npm package): A lightweight library function specifically designed for fast JSON copying.
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.
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

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.
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.
fastest-json-copy (npm package):
- Pros: lightweight, fast, and efficient.
- Cons: may have compatibility issues with older browsers or Node versions.
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.
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:

fastest-json-copy (npm package)
rfdc()
jsondiffpatch.clone()

LLMs can make mistakes. Check important info.

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

**Benchmark Overview**

**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 5 months ago):