Benchmark: deepclone vs deepfreeze vs saferdeepclone2

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...'
  }
};

function deepFreeze(object) {
    for (const v of Array.isArray(object) ? object : Object.values(object)) {
        if (v && typeof v === 'object') {
            deepFreeze(v);
        }
    }
    Object.freeze(object);
    return object;
}

function deepClone(object) {
    if (Array.isArray(object)) {
      const len = object.length;
      const result = new Array(len);
      for (let i = 0; i < len; ++i) {
        const v = object[i];
        result[i] = v && typeof v === 'object' ? deepClone(v) : v;
      }
      return result;
    } else {
      const result = {};
      for (const k in object) {
        const v = object[k];
        result[k] = v && typeof v === 'object' ? deepClone(v) : v;
      }
      return result;
    }
}
function deepCloneSafe(object) {
    if (!object) {
        return object;
    }
    if (typeof object !== 'object') {
        // this is not an array or an object, it's a primitive...
        // having a type system doesn't 100% prevent this...
        return object;
    }
    // also.. hopefully nobody ever uses `new String('a')` or `new Number(1)`
    // but protect against that edge case anyways..
    if (typeof object.valueOf() !== 'object') {
        return new (object.constructor)(object.valueOf());
    }
    if (Array.isArray(object)) {
      const len = object.length;
      const result = new Array(len);
      for (let i = 0; i < len; ++i) {
        const v = object[i];
        result[i] = v && typeof v === 'object' ? deepCloneSafe(v) : v;
      }
      return result;
    } else {
      const result = {};
      for (const k in object) {
        const v = object[k];
        result[k] = v && typeof v === 'object' ? deepCloneSafe(v) : v;
      }
      return result;
    }
}

var myCopy = null;

Tests:

Lodash cloneDeep
myCopy = _.cloneDeep(MyObject);
Json clone
myCopy = JSON.parse(JSON.stringify(MyObject));
freeze and destructure
Object.freeze(MyObject); myCopy = { ...MyObject };
deepClone
myCopy = deepClone(MyObject)
deepFreeze
deepFreeze(MyObject); myCopy = MyObject
deepCloneSafe
myCopy = deepCloneSafe(MyObject)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash cloneDeep
Json clone
freeze and destructure
deepClone
deepFreeze
deepCloneSafe

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 years ago)

User agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:121.0) Gecko/20100101 Firefox/121.0

Browser/OS: Firefox 121 on Ubuntu

View result in a separate tab

Test name	Executions per second
Lodash cloneDeep	1333585.8 Ops/sec
Json clone	643772.1 Ops/sec
freeze and destructure	4964581.5 Ops/sec
deepClone	9988056.0 Ops/sec
deepFreeze	3220443.0 Ops/sec
deepCloneSafe	9524628.0 Ops/sec

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

LLMs can make mistakes. Check important info.

I'd be happy to help explain what's being tested in the provided benchmark.

**Benchmark Overview**

The benchmark compares the performance of four different methods for creating deep copies of an object:

1. `deepCloneSafe`
2. `deepClone`
3. `freeze` and `destructure`
4. Lodash's `cloneDeep`

Each method is executed multiple times with a different number of iterations, and their execution rates are measured.

**What's being tested?**

Here's what each method does:

* `deepCloneSafe`: A safer version of `deepClone`, which checks for primitive values instead of relying on `typeof` checks. It also uses the `constructor` property to create a new instance of the object's constructor, reducing memory allocation overhead.
* `deepClone`: The original deep cloning function, which recursively creates new objects and arrays by copying their properties.
* `freeze` and `destructure`: A combination of `Object.freeze()` and destructuring assignment (`{ ...MyObject }`). `Object.freeze()` freezes the object, making it immutable, while destructuring assignment creates a shallow copy of the object's properties.
* Lodash's `cloneDeep`: A specialized function for deep cloning objects and arrays.

**Options compared**

The benchmark compares these four methods across different execution rates:

* Execution rate (executions per second)
* Memory usage

**Pros and Cons**

Here are some pros and cons for each method:

* `deepCloneSafe`:
	+ Pros: Safer, more robust than `deepClone`, protects against edge cases like `new String('a')`.
	+ Cons: May be slower due to additional checks.
* `deepClone`:
	+ Pros: Fast, simple implementation.
	+ Cons: Insecure, may fail with certain types of data (e.g., objects with non-boolean properties).
* `freeze` and `destructure`:
	+ Pros: Shallow copy, fast, and efficient.
	+ Cons: Only creates a shallow copy, not suitable for deep cloning.
* Lodash's `cloneDeep`:
	+ Pros: Robust, well-tested implementation specifically designed for deep cloning.
	+ Cons: May be slower than `deepCloneSafe` due to additional overhead.

**Benchmark Results**

The latest benchmark results show that:

* `deepCloneSafe` is the fastest, with an average execution rate of around 1.5-2 times faster than `deepClone`.
* Lodash's `cloneDeep` is also a strong contender, but slightly slower than `deepCloneSafe`.
* `freeze` and `destructure` are relatively slow compared to the other methods.

Keep in mind that these results may vary depending on the specific use case, data structure, and JavaScript engine being used.

Related benchmarks:

deepclone vs deepfreeze vs saferdeepclone2 (version: 0)

Make deepclone safer, but check that it's not too much slower.

Comparing performance of: Lodash cloneDeep vs Json clone vs freeze and destructure vs deepClone vs deepFreeze vs deepCloneSafe

Created: 2 years ago by: Guest

Jump to the latest result

Lodash cloneDeep

Json clone

freeze and destructure

deepClone

deepFreeze

deepCloneSafe

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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