Benchmark: Deep copy algo vs JSON manipulation - 120k lines of prices

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.");
};

function generate_data() {
  let data = {
    'prices': [],
    'other_prices' : [],
    'my object': [
      {'object a': 'object object'},
      {'object b': 'object object'}, 
      {'object c': 'object object', 'objectd': 36}, 
      5
    ]
  };

  // Helper function to generate random product names
  function generateProductName() {
    const products = ['Laptop', 'Phone', 'Tablet', 'Headphone', 'Speaker', 'Monitor', 'Keyboard', 'Mouse', 'Smartwatch', 'Camera'];
    const adjectives = ['Super', 'Ultra', 'Pro', 'Max', 'Plus', 'Lite', 'Mini', 'Advanced', 'Portable', 'Wireless'];
    const randomProduct = products[Math.floor(Math.random() * products.length)];
    const randomAdjective = adjectives[Math.floor(Math.random() * adjectives.length)];
    return `${randomAdjective} ${randomProduct}`;
  }

  // Helper function to generate random prices
  function generatePrice() {
    return (Math.random() * 1000).toFixed(2); // Random price between 0 and 1000 with 2 decimal places
  }

  // Generate 6000 product name and price entries
  for (let i = 0; i < 60000; i++) {
    const product = generateProductName();
    const price = generatePrice();
    data['prices'].push({ 'product': product, 'price': parseFloat(price) });
  }
  for (let i = 0; i < 60000; i++) {
    const product = generateProductName();
    const price = generatePrice();
    data['other_prices'].push({ 'product': product, 'price': parseFloat(price) });
  }

  return data;
};

var data = generate_data();

Tests:

JSON copy
a = JSON.parse(JSON.stringify(data));
Deep copy
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 one month ago):

LLMs can make mistakes. Check important info.

The benchmark provided compares two different techniques for deep copying a complex JavaScript object containing a large dataset, specifically one representing a list of prices generated programmatically. The two methods being tested are:

1. **JSON Copy**: Using `JSON.parse(JSON.stringify(data));`
2. **Deep Copy Function**: Using a custom defined recursive function called `deepCopy(data);`

### Options Compared

#### 1. JSON Copy
- **Description**: This method takes advantage of the fact that JSON serialization can generate a deep copy of an object by first converting the object to a JSON string and then parsing that string back into a new JavaScript object.
- **Pros**:
  - **Simplicity**: Easy to implement and understand.
  - **Performance**: For simple objects that do not include functions, Dates, or circular references, it can be quite fast.
- **Cons**:
  - **Loss of Type Information**: Does not handle special object types like Dates, Functions, or RegEx. Any objects that are included will be converted to plain objects.
  - **Circular References**: Will throw an error if the data structure contains circular references.
  - **Performance Limitations**: As the complexity of the object increases, this method may become less performant compared to specialized deep copy functions.

#### 2. Deep Copy Function
- **Description**: This method involves a custom recursive function that explicitly checks the type of each property and handles them accordingly.
- **Pros**:
  - **Type Preservation**: Properly handles Dates, Arrays, and nested objects, ensuring that the resulting copied object maintains the inherent types of the original.
  - **No Circular Reference Issue**: Can be adapted to handle circular references with modifications.
- **Cons**:
  - **Complexity**: More code and lines of logic to maintain, which could introduce bugs.
  - **Performance**: Depending on the implementation, recursion can lead to performance bottlenecks, especially for very large nested structures, and can cause stack overflow errors.

### Other Considerations
- **Memory Usage**: Both methods will require significant memory, but the JSON approach may allocate more intermediate string representation memory during its operations.
- **Usability**: For many common use cases, the JSON copy method may suffice because of its ease of use. However, specific applications requiring a more complex understanding of JavaScript objects might prefer the deep copy implementation for its fidelity in maintaining data types.

### Going Beyond: Other Alternatives
- **Lodash's `cloneDeep`**: This third-party library provides a deep cloning utility that handles complex structures including nested arrays, objects, and special cases (like Date objects) better than both methods mentioned above. 
  - **Pros**: Robustness, better performance in complex scenarios, well-tested library.
  - **Cons**: Dependency on an external library requires adding that to your project.
  
- **Structured Clone**: In modern JavaScript environments, `structuredClone()` can be used as a native solution for deep cloning objects, even handling various corner cases, like Maps and Sets. 
  - **Pros**: Built-in, handles more data types.
  - **Cons**: Limited support in older JavaScript environments may lead to compatibility issues.

In summary, the choice between these two methods (JSON copy vs. a custom deep copy function) largely depends on the nature of the data being copied, the project requirements regarding type fidelity, performance concerns, and the development environment. For most software engineers, understanding the differences between these methods and their implications on data integrity and performance is crucial for effective JavaScript programming.

Latest run results:

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

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

Browser/OS: Chrome 131 on Windows

View result in a separate tab

Test name	Executions per second
JSON copy	25.7 Ops/sec
Deep copy	82.9 Ops/sec

Related benchmarks:

Deep copy algo vs JSON manipulation - 120k lines of prices (version: 0)

Comparing performance of: JSON copy vs Deep copy

Created: one month 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 one month ago):