Benchmark: JSON.stringify vs structuredClone vs simple deepCopyObject 2

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;
}
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);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
JSON.stringify
structuredClone
deepCopyObject
deepCopyObjectSimple

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year 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	1468337.9 Ops/sec
structuredClone	832004.2 Ops/sec
deepCopyObject	1333945.2 Ops/sec
deepCopyObjectSimple	3525647.5 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark.

**What is being tested?**

The benchmark measures the performance of three different methods for creating a deep copy of an object in JavaScript: `JSON.stringify`, `structuredClone`, and two custom implementations (`deepCopyObject` and `deepCopyObjectSimple`). The test creates an object `MyObject` with nested properties, including a `jayson` property that contains a JSON string. The goal is to compare the execution speed of these four methods.

**Options compared**

The three custom implementation options are:

1. **`JSON.stringify`**: This method converts a JavaScript value to a JSON string and then parses it back into an object.
2. **`structuredClone`**: This method creates a deep copy of an object by cloning its properties using a structured clone algorithm.
3. **`deepCopyObject`**: A custom implementation that recursively copies the object's properties, handling specific types like `Date`, `Set`, and `Map`.
4. **`deepCopyObjectSimple`**: Another custom implementation that also recursively copies the object's properties but with some differences in implementation details compared to `deepCopyObject`.

**Pros and cons of each approach**

1. **`JSON.stringify`**:
	* Pros: Simple, widely supported, and easy to implement.
	* Cons: Can be slow for large objects due to the overhead of stringification and parsing, and may not work as expected with certain data types (e.g., `Date`, `Set`, and `Map`).
2. **`structuredClone`**:
	* Pros: Designed for performance and efficiency, handles complex data structures, and is part of the ECMAScript standard.
	* Cons: May require additional setup or polyfills in older browsers, and its usage may not be well-known to developers.
3. **`deepCopyObject`**:
	* Pros: Custom implementation that provides more control over the copying process, handles specific types like `Date`, `Set`, and `Map`.
	* Cons: May require additional development effort, and its performance may not be as optimized as `structuredClone`.
4. **`deepCopyObjectSimple`**:
	* Pros: Similar to `deepCopyObject` but with some differences in implementation details.
	* Cons: Performance may vary depending on the specific implementation.

**Library/Features used**

1. None explicitly mentioned, but `structuredClone` is a built-in feature of modern JavaScript engines (starting from ECMAScript 2020).
2. No special JS features or syntax are used beyond what's standard in JavaScript.

**Other alternatives**

If you were to add additional methods to the benchmark, some alternative approaches could be:

1. **Lodash's `cloneDeep`**: A popular utility library that provides a deep cloning function for various data structures.
2. **Immer.js**: A library that offers a more efficient and safer way to update objects by providing an immutable version of the original object.
3. **Object.assign() with `Object.create()`**: A simple method to create a new object by copying the properties from another object.

Keep in mind that these alternatives may have their own set of trade-offs, performance characteristics, and usage patterns, which could impact the benchmark's results.

Related benchmarks:

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

JSON.stringify vs structuredClone vs simple deepCopyObject 2

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

Created: one year ago by: Guest

Jump to the latest result

JSON.stringify

structuredClone

deepCopyObject

deepCopyObjectSimple

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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