Benchmark: deepclone vs deepfreeze vs saferdeepclone

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' ? 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;
    }
}

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 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 Edg/120.0.0.0

Browser/OS: Chrome 120 on Windows

View result in a separate tab

Test name	Executions per second
Lodash cloneDeep	987163.8 Ops/sec
Json clone	598884.3 Ops/sec
freeze and destructure	2726979.8 Ops/sec
deepClone	1907097.8 Ops/sec
deepFreeze	1073311.4 Ops/sec
deepCloneSafe	1914887.1 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down what is being tested in this benchmark.

The main goal of the benchmark is to compare the performance of three different methods for creating deep clones of an object: `deepClone`, `deepFreeze`, and `deepCloneSafe`. The focus is on making `deepClone` safer, but still checking that it's not too much slower than the other two approaches.

**Methods being compared:**

1. **`deepClone`**: This method creates a deep clone of an object by recursively iterating over its properties and creating new objects for each one.
2. **`deepFreeze`**: This method freezes the original object in place, making it immutable. The cloned object is then created using the `Object.assign()` method or other means.
3. **`deepCloneSafe`**: This method creates a deep clone of an object while also providing some protection against creating new primitive values (e.g., strings, numbers) that might not be what's intended.

**Pros and Cons:**

* **`deepClone`**:
	+ Pros: Fastest execution time among the three methods.
	+ Cons: May create unexpected behavior if used with non-objects or objects that contain complex logic.
* **`deepFreeze`**:
	+ Pros: Provides immutability, which can be beneficial for certain types of data structures.
	+ Cons: Can be slower than `deepClone`, as the original object needs to be frozen in place before cloning.
* **`deepCloneSafe`**:
	+ Pros: Provides an additional layer of protection against creating unexpected primitive values.
	+ Cons: May be slightly slower than `deepFreeze` due to the extra checks and logic.

The benchmark results show that:

1. `freeze and destructure` is the fastest method, likely due to its use of `Object.assign()` which can be optimized by browsers.
2. `deepCloneSafe` is slightly slower than `freeze and destructure`, but still faster than `deepFreeze`.
3. `deepClone` is the slowest method.

Overall, the benchmark highlights the trade-offs between immutability, performance, and safety when creating deep clones of objects. The results suggest that `freeze and destructure` might be a good default choice for many use cases, while `deepCloneSafe` provides an additional layer of protection against unexpected behavior.

Related benchmarks:

deepclone vs deepfreeze vs saferdeepclone (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):