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

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

Autogenerated LLM Summary (model llama3.2:3b, generated one year 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?

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: 3 years 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>

Fastest: N/A

Slowest: N/A

No previous run results

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