Benchmark: JSON.stringify vs structuredClone vs simple deepCopyObject 3

Script Preparation code:

var deepCopyObject = (inObject) => {
  if (inObject instanceof Date) return inObject

  if (inObject instanceof Set) return new Set(inObject)

  if (inObject instanceof Map) return new Map(inObject)

  if (typeof inObject !== 'object' || inObject === null) {
    return inObject // Return the value if inObject is not an object
  }

  // Create an array or object to hold the values
  const outObject = Array.isArray(inObject) ? [] : {}

  Object.keys(inObject).forEach((key) => {
    const value = inObject[key]

    // Recursively (deep) copy for nested objects, including arrays
    outObject[key] = typeof value === 'object' && value !== null ? deepCopyObject(value) : value
  })

  return outObject
}

function deepCopyObjectSimple(inObject) {
  if (typeof inObject !== 'object' || inObject === null) {
    return inObject;
  }

  const outObject = Array.isArray(inObject) ? [] : {};

  for (const key in inObject) {
    const value = inObject[key];
    outObject[key] = (typeof value === 'object' && value !== null) ? deepCopyObjectSimple(value) : value;
  }

  return outObject;
}

function deepCopyObjectIterative(inObject) {
  if (typeof inObject !== 'object' || inObject === null) {
    return inObject;
  }

  const stack = [{ source: inObject, target: Array.isArray(inObject) ? [] : {} }];
  const root = stack[0].target;

  while (stack.length > 0) {
    const { source, target } = stack.pop();

    for (const key in source) {
      const value = source[key];
      if (typeof value === 'object' && value !== null) {
        target[key] = Array.isArray(value) ? [] : {};
        stack.push({ source: value, target: target[key] });
      } else {
        target[key] = value;
      }
    }
  }

  return root;
}

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...'
  }
};

var myCopy = null;

Tests:

JSON.stringify
myCopy = JSON.parse(JSON.stringify(MyObject));
structuredClone
myCopy = structuredClone(MyObject);
deepCopyObject
myCopy = deepCopyObject(MyObject);
deepCopyObjectSimple
myCopy = deepCopyObjectSimple(MyObject);
deepCopyObjectIterative
myCopy = deepCopyObjectIterative(MyObject);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
JSON.stringify
structuredClone
deepCopyObject
deepCopyObjectSimple
deepCopyObjectIterative

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and analyze each test case.

**Benchmark Definition**

The benchmark is comparing four different approaches to create a deep copy of an object:

1. `JSON.stringify`
2. `structuredClone`
3. `deepCopyObject` (a custom implementation)
4. `deepCopyObjectSimple` (another custom implementation)
5. `deepCopyObjectIterative` (yet another custom implementation)

**Options Compared**

The options being compared are the performance and complexity of each approach:

* **JSON.stringify**: converts a JavaScript object to a JSON string, which can be parsed back into an object.
* **structuredClone**: creates a deep clone of an object using Web APIs.
* `deepCopyObject` and `deepCopyObjectSimple`: custom implementations that recursively copy the object's properties.
* `deepCopyObjectIterative`: another custom implementation that uses a stack-based approach to recursively copy the object's properties.

**Pros and Cons**

Here's a brief summary of each approach:

1. **JSON.stringify**:
	* Pros: simple, widely supported.
	* Cons: not designed for deep copying, can lead to loss of metadata, and has limitations with certain data types (e.g., dates, sets).
2. **structuredClone**:
	* Pros: modern, efficient, and designed specifically for deep cloning.
	* Cons: requires Web APIs support.
3. **deepCopyObject** and **deepCopyObjectSimple**:
	* Pros: custom implementations that can handle complex data structures.
	* Cons: require manual implementation, which can lead to errors and inconsistencies.
4. **deepCopyObjectIterative**:
	* Pros: uses a stack-based approach, which can be efficient for large objects.
	* Cons: more complex implementation than `deepCopyObject`, may have performance overhead.

**Other Considerations**

When choosing an approach, consider the following factors:

* Performance: `structuredClone` is likely to be the fastest option, followed by `deepCopyObjectIterative`.
* Complexity: `deepCopyObject` and `deepCopyObjectSimple` require manual implementation, while `structuredClone` uses Web APIs.
* Compatibility: `JSON.stringify` has wider support than custom implementations.

**Benchmark Results**

The latest benchmark results show that:

1. `structuredClone` is the fastest option ( lowest executions per second).
2. `deepCopyObjectIterative` is close in performance to `structuredClone`.
3. `deepCopyObjectSimple` and `deepCopyObject` are slower, likely due to the manual implementation.

These results suggest that `structuredClone` is a good choice for deep copying objects, as it offers a balance of performance and compatibility.

Latest run results:

Run details: (Test run date: 4 months ago)

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

Browser/OS: Chrome 126 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
JSON.stringify	1446061.1 Ops/sec
structuredClone	817268.3 Ops/sec
deepCopyObject	1303167.8 Ops/sec
deepCopyObjectSimple	3451855.5 Ops/sec
deepCopyObjectIterative	3508498.8 Ops/sec

Related benchmarks:

JSON.stringify vs structuredClone vs simple deepCopyObject 3 (version: 0)

JSON.stringify vs structuredClone vs simple deepCopyObject 3

Comparing performance of: JSON.stringify vs structuredClone vs deepCopyObject vs deepCopyObjectSimple vs deepCopyObjectIterative

Created: 4 months ago by: Guest

Jump to the latest result

JSON.stringify

structuredClone

deepCopyObject

deepCopyObjectSimple

deepCopyObjectIterative

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