Benchmark: Deep copy algo vs JSON manipulation

Script Preparation code:

function deepCopy(obj) {
    var copy;

    // Handle the 3 simple types, and null or undefined
    if (null == obj || "object" != typeof obj) return obj;

    // Handle Date
    if (obj instanceof Date) {
        copy = new Date();
        copy.setTime(obj.getTime());
        return copy;
    }

    // Handle Array
    if (obj instanceof Array) {
        copy = [];
        for (var i = 0, len = obj.length; i < len; i++) {
            copy[i] = deepCopy(obj[i]);
        }
        return copy;
    }

    // Handle Object
    if (obj instanceof Object) {
        copy = {};
        for (var attr in obj) {
            if (obj.hasOwnProperty(attr)) copy[attr] = deepCopy(obj[attr]);
        }
        return copy;
    }

    throw new Error("Unable to copy obj! Its type isn't supported.");
};

Tests:

JSON copy
const data = {'my object' : [{'object a' : 'object object'},{'object b' : 'object object'}, {'object c' : 'object object', 'objectd': 36}, 5]} a = JSON.parse(JSON.stringify(data));
Deep copy
const data = {'my object' : [{'object a' : 'object object'},{'object b' : 'object object'}, {'object c' : 'object object', 'objectd': 36}, 5]} a = deepCopy(data);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
JSON copy
Deep copy

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 29 days ago):

LLMs can make mistakes. Check important info.

The benchmark provided tests two different methods for creating a deep copy of a JavaScript object: one using JSON manipulation (`JSON.parse(JSON.stringify(data))`) and the other using a custom deep copy function (`deepCopy(obj)`). Here’s a breakdown of each approach, including their pros, cons, and alternative methods.

### Approaches Compared

1. **JSON Copy Method**:
   ```javascript
   const data = {'my object' : [{'object a' : 'object object'},{'object b' : 'object object'}, {'object c' : 'object object', 'objectd': 36}, 5]}
   a = JSON.parse(JSON.stringify(data));
   ```

- **Description**: This method serializes an object to a JSON string and then parses it back to create a new object, effectively creating a deep copy.
   - **Pros**:
     - **Simplicity**: One-liner that is straightforward and easy to understand.
     - **Built-in Support**: Leverages JavaScript's built-in JSON methods, which are well-optimized in most JavaScript engines.
   - **Cons**:
     - **Data Loss**: It cannot handle functions, Date objects, undefined values, or circular references. For instance, any method or property of an object that is not serializable will be lost during the copy.
     - **Performance and Overhead**: Serialization and deserialization introduce overhead, which may be noticeable with large objects.
  
2. **Deep Copy Function**:
   ```javascript
   function deepCopy(obj) { ... }
   const data = {'my object' : [{'object a' : 'object object'},{'object b' : 'object object'}, {'object c' : 'object object', 'objectd': 36}, 5]}
   a = deepCopy(data);
   ```

- **Description**: This is a custom function that recursively creates a copy of an object. It handles simple data types, arrays, objects, and Date objects.
   - **Pros**:
     - **Flexibility**: Can properly handle complex structures, including Date objects and arrays.
     - **Preservation of Properties**: Maintains properties and methods of objects that can’t be serialized through JSON.
   - **Cons**:
     - **Complexity**: More code and can be less intuitive, particularly for developers unfamiliar with recursive functions.
     - **Performance**: Performance can degrade with nested structures, as each property must be processed recursively.

### Benchmarking Results

From the latest benchmark results:
- **JSON Copy** performed at approximately **1,294,626 executions per second**.
- **Deep Copy** performed at approximately **793,125 executions per second**.

It indicates that the `JSON` method is significantly faster than the custom `deepCopy`.

### Considerations

When choosing between these methods, consider the specific data you expect to work with:
- If the object can be fully represented with JSON (i.e., no functions, Dates, or circular references), the JSON method is generally preferred for performance.
- If you need to maintain complex structures, such as Date objects or need to handle functions, the custom deep copy method would be more appropriate.

### Alternatives

1. **Shallow Copy Options**:
   - **Object.assign**: Creates a shallow copy of an object. Suitable only for objects without nested structures.
   - **Spread Operator** (`{...obj}`): Also creates a shallow copy, similar to Object.assign.

2. **Lodash Library**: 
   - Provides a method called `_.cloneDeep()` for deep copying objects. It offers a robust solution for deep cloning, handling various data types and complex nested objects effectively.

3. **StructuredClone API** (available in recent JavaScript versions):
   - This native method can create deep copies of objects, supporting many types including Date, Map, Set, etc. It’s a growing alternative to consider as it is built into the browser environment.

In conclusion, while the benchmark provides valuable insights into the performance of the two copying methodologies, the choice between them should consider the structure of the data, desired functionality, and potential edge cases. Each alternative has its strengths and weaknesses, making them suitable for different contexts in JavaScript programming.

Latest run results:

Run details: (Test run date: 27 days ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36

Browser/OS: Chrome 130 on Windows

View result in a separate tab

Test name	Executions per second
JSON copy	563373.0 Ops/sec
Deep copy	351385.4 Ops/sec

Related benchmarks:

Deep copy algo vs JSON manipulation (version: 0)

Comparing performance of: JSON copy vs Deep copy

Created: 29 days ago by: Guest

Jump to the latest result

JSON copy

Deep copy

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 29 days ago):