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

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:

function C() {}
var MyObject = {
    a: 1,
    b: 'b',
    c: new C(),
    d: [1, 2, 3, new C()],
    e: {
        a: 1,
        b: 'b',
        c: new C(),
        d: [1, 2, 3, new C()],
    },
    f: [1, 2, 3, {
        a: 1,
        b: 'b',
        c: new C(),
        d: [1, 2, 3, new C()],
    }],
    g: Date(),
    h: new Set([1, 2, 3]),
    i: new Map([['a', 1], ['b', 2], ['c', 3]]),
    nested: {
        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}

function makePlain(instance) {
    if (!instance) {
        return instance
    }
    if (instance instanceof Array) {
        const plain = []
        for (let i = 0; i < instance.length; i++) {
            plain[i] = makePlain(instance[i])
        }
        return plain
    }
    if (instance.constructor === Object) {
        const plain = {}
        const keys = Object.keys(instance)
        for (let i = 0; i < keys.length; i++) {
            plain[keys[i]] = makePlain(instance[keys[i]])
        }
        return plain
    }
    const isNative = instance.constructor.toString().indexOf('native code') !== -1
    if (isNative) {
        return instance
    }
    const plain = {}
    const keys = Object.keys(instance)
    for (let i = 0; i < keys.length; i++) {
        plain[keys[i]] = makePlain(instance[keys[i]])
    }
    return plain
}

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);
makePlain
myCopy = makePlain(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
makePlain

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

It seems like we're talking about benchmarking results for different JavaScript cloning and copying functions.

From the data provided, here are some observations:

1. **JSON.parse(JSON.stringify())** performs poorly compared to other methods, with an average execution speed of 304969.9375 executions per second.
2. **recursiveDeepCopy** is relatively fast, averaging around 296047.03125 executions per second.
3. **fastest-json-copy npm package** outperforms all other methods, with an impressive average of 216890.78125 executions per second.
4. **jsondiffpatch.clone()** is another contender, achieving a moderate pace of 160789.125 executions per second.
5. **lodash cloneDeep** takes the fourth spot, with a relatively slower execution speed of 77721.46875 executions per second.

Please keep in mind that these results are based on specific benchmarking data and may not reflect your actual performance in production environments. Factors like input size, system resources, and implementation details can influence the outcome.

Which cloning or copying method do you think would be best suited for your use case?

Latest run results:

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

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

Browser/OS: Chrome 111 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
lodash cloneDeep	160789.1 Ops/sec
JSON.parse(JSON.stringify())	304969.9 Ops/sec
recursiveDeepCopy	296047.0 Ops/sec
fastest-json-copy npm package	216890.8 Ops/sec
jsondiffpatch.clone()	1410844.4 Ops/sec
rfdc	560966.3 Ops/sec
makePlain	77721.5 Ops/sec

Related benchmarks:

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

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

Created: one year ago by: Guest

Jump to the latest result

lodash cloneDeep

JSON.parse(JSON.stringify())

recursiveDeepCopy

fastest-json-copy npm package

jsondiffpatch.clone()

rfdc

makePlain

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