Benchmark: inbuilt structuredClone vs deepClone

Script Preparation code:

var voucher = {
    "single": false,
    "applyOverTaxes": false,
    "discountType": "1",
    "value": 100,
    "minimumAmount": 0,
    "quantity": 1,
    "suffixLength": 8,
    "code": "IF5R0AFX",
    "vertical": [],
    "allowedPaymentMethods": [],
    "allowedBanks": [],
    "types": [],
    "partners": [],
    "deepvalue": {"this": "that"},
    "startDate": "2020-10-21T00:00:00.000Z",
    "endDate": "2020-10-21T00:00:00.000Z",
    "applyed": false
}

function deepClone(o) {
    if (typeof o !== "object") {
      return o
    }
    if (!o) {
      return o
    }

    // https://jsperf.com/deep-copy-vs-json-stringify-json-parse/25
    if (Array.isArray(o)) {
      const newO = []
      for (let i = 0; i < o.length; i += 1) {
        const val = !o[i] || typeof o[i] !== "object" ? o[i] : deepClone(o[i])
        newO[i] = val === undefined ? null : val
      }
      return newO
    }

    const newO = {}
    for (const i of Object.keys(o)) {
      const val = !o[i] || typeof o[i] !== "object" ? o[i] : deepClone(o[i])
      if (val === undefined) {
        continue
      }
      newO[i] = val
    }
    return newO
  }

Tests:

structuredClone
const copy = structuredClone(voucher);
deepClone https://github.com/nodejs/node/issues/34355#issuecomment-658394617
const copy = deepClone(voucher);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
structuredClone
deepClone https://github.com/nodejs/node/issues/34355#issuecomment-658394617

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/121.0.0.0 Safari/537.36 Edg/121.0.0.0

Browser/OS: Chrome 121 on Windows

View result in a separate tab

Test name	Executions per second
structuredClone	212633.2 Ops/sec
deepClone https://github.com/nodejs/node/issues/34355#issuecomment-658394617	237047.0 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark and explain what's being tested, compared, and their pros and cons.

**Benchmark Definition**

The benchmark is comparing two cloning functions: `structuredClone` and `deepClone`. The goal is to determine which function is faster and more efficient for copying complex objects in JavaScript.

**Options being compared**

There are two options being compared:

1. **`structuredClone`**: This is a relatively new function introduced in ECMAScript 2020 (ES2020) as part of the Web APIs. It's designed to create a deep clone of an object, preserving its properties and values.
2. **`deepClone`**: This is a custom implementation provided by the Node.js team as part of issue #34355 on GitHub. It's a manual implementation that creates a deep copy of an object using a recursive approach.

**Pros and Cons**

* **`structuredClone`**:
	+ Pros: Designed for cloning objects, efficient, and standardized across browsers.
	+ Cons: Limited to ES2020 and newer browsers; might not work in older versions or non-browser environments.
* **`deepClone`**:
	+ Pros: Custom implementation, tested on various browsers, including older ones; allows for fine-tuning and optimization.
	+ Cons: Not standardized, may have performance issues due to manual implementation, and requires more effort to maintain.

**Library/Custom Implementation**

The `structuredClone` function is a built-in JavaScript API introduced in ES2020. The `deepClone` function is a custom implementation provided by the Node.js team for older browsers that don't support `structuredClone`.

**Special JS Feature/Syntax**

None mentioned.

**Other Alternatives**

If you want to clone objects manually without using `structuredClone`, you can use the following alternatives:

* **JSON.parse(JSON.stringify(obj))**: This method creates a shallow copy of an object by serializing it as JSON and then parsing the resulting string back into an object.
* **Array.prototype.slice.call(Array.prototype.splice.call(obj))**: This method creates a deep copy of an array-like object using `splice` to create a new array with the same values.

Keep in mind that these alternatives may not be as efficient or safe as `structuredClone`.

**Benchmark Preparation Code**

The provided script preparation code defines an object `voucher` and two cloning functions: `deepClone` and `structuredClone`. The benchmark uses these functions to clone the `voucher` object.

**Individual Test Cases**

There are two test cases:

1. **`structuredClone`**: This test case clones the `voucher` object using the `structuredClone` function.
2. **`deepClone https://github.com/nodejs/node/issues/34355#issuecomment-658394617`**: This test case clones the `voucher` object using the custom `deepClone` implementation from issue #34355 on GitHub.

The benchmark results show that Chrome 121 (on Windows Desktop) performs significantly better with `structuredClone` than with `deepClone`.

Related benchmarks:

inbuilt structuredClone vs deepClone (version: 0)

Comparing performance of: structuredClone vs deepClone https://github.com/nodejs/node/issues/34355#issuecomment-658394617

Created: 2 years ago by: Guest

Jump to the latest result

structuredClone

deepClone https://github.com/nodejs/node/issues/34355#issuecomment-658394617

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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