Benchmark: lodash clonedeep vs json.parse(stringify()) vs recursivecopy vs structuredClone

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>

Script Preparation code:

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;

function recursiveDeepCopy(o) {
    var newO,
      i;
  
    if (typeof o !== 'object') {
      return o;
    }
    if (!o) {
      return o;
    }
  
    if ('[object Array]' === Object.prototype.toString.apply(o)) {
      newO = [];
      for (i = 0; i < o.length; i += 1) {
        newO[i] = recursiveDeepCopy(o[i]);
      }
      return newO;
    }
  
    newO = {};
    for (i in o) {
      if (o.hasOwnProperty(i)) {
        newO[i] = recursiveDeepCopy(o[i]);
      }
    }
    return newO;
  }

Tests:

Lodash CloneDeep
myCopy = _.cloneDeep(MyObject);
Json Clone
myCopy = JSON.parse(JSON.stringify(MyObject));
recursiveDeepCopy
myCopy = recursiveDeepCopy(MyObject);
structuredClone
myCopy = structuredClone(MyObject)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash CloneDeep
Json Clone
recursiveDeepCopy
structuredClone

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36

Browser/OS: Chrome 132 on Linux

View result in a separate tab

Test name	Executions per second
Lodash CloneDeep	616432.4 Ops/sec
Json Clone	524355.4 Ops/sec
recursiveDeepCopy	2202011.2 Ops/sec
structuredClone	242811.3 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 2 months ago):

LLMs can make mistakes. Check important info.

The benchmark provided assesses four different methods for creating a deep copy of an object in JavaScript. Each method is tested in terms of its performance, measured by executions per second.

### Comparison of Approaches

1. **Lodash CloneDeep** (`myCopy = _.cloneDeep(MyObject);`):
   - **Library**: Lodash is a widely used utility library in JavaScript that provides various functions for common programming tasks like manipulating and copying objects.
   - **Pros**:
     - Simple and straightforward API.
     - Handles various data types well, including arrays, objects, and nested structures.
   - **Cons**:
     - Overhead of importing the entire Lodash library, which can increase the overall bundle size if only using a function or two.
     - Slightly slower compared to some native options.
  
2. **JSON Clone** (`myCopy = JSON.parse(JSON.stringify(MyObject));`):
   - **Pros**:
     - Utilizes native JavaScript functions, meaning no additional libraries are required.
     - Simple to understand and write.
   - **Cons**:
     - Only works for serializable objects, which means it cannot handle functions, `Date` objects, `undefined`, or circular references.
     - Potentially inefficient for larger objects as it serializes and parses the entire object.

3. **Recursive Deep Copy** (`myCopy = recursiveDeepCopy(MyObject);`):
   - **Custom Function**: A user-defined function that implements a recursive approach to copying objects deeply.
   - **Pros**:
     - Tailored to specific needs, allowing for more control over how certain data types are handled.
     - Can be optimized further, depending on the specific requirements of the objects being copied.
   - **Cons**:
     - More verbose and possibly less optimized compared to built-in or library options.
     - May require more careful handling of edge cases (e.g., circular references).

4. **Structured Clone** (`myCopy = structuredClone(MyObject);`):
   - **Pros**:
     - Built-in method specifically designed for deep cloning, capable of handling various types, including `Date`, `Map`, `Set`, `ArrayBuffer`, and `Blob`.
     - Avoids the limitations of the JSON method since it can copy complex data types.
   - **Cons**:
     - Might not be supported in older browsers, though it is increasingly becoming part of the standard.
     - May have performance overhead compared to a simple recursive function for straightforward objects.

### Benchmark Results

The latest benchmark results indicate the following performance in terms of executions per second:

1. **Recursive Deep Copy**: 2,202,011.25
2. **Lodash CloneDeep**: 616,432.44
3. **JSON Clone**: 524,355.38
4. **Structured Clone**: 242,811.30

### Considerations

- **Performance Needs**: Depending on the size and complexity of the object being copied, developers might choose a faster option for performance-critical applications. The recursive method performed significantly better than the others in this benchmark, making it potentially a better choice for frequent deep copying operations.
- **Object Complexity**: If the objects contain non-serializable types, the JSON method will not be suitable. In such cases, using either Lodash or the structured clone method would be preferable.
- **Library Dependency**: Using Lodash adds an external dependency, which might be a consideration, especially for projects aiming to minimize external libraries.
- **Implementation Time**: For quick implementations without needing extensive object copying capabilities, JSON cloning can be an easy and straightforward choice.

### Alternatives

Alternatives to the methods tested include:

- **Shallow Copy**: Using `Object.assign` or the spread operator (`{...obj}`) for shallow copying.
- **Other Libraries**: Utilizing libraries like Rambda or Immer, which offer their own methods for deep cloning or state management strategies.
- **Custom Implementations**: Crafting specialized copy functions tailored for unique types and application requirements.

Understanding these options allows developers to choose the most appropriate method for their specific application needs.

Related benchmarks:

lodash clonedeep vs json.parse(stringify()) vs recursivecopy vs structuredClone (version: 1)

Comparing performance of: Lodash CloneDeep vs Json Clone vs recursiveDeepCopy vs structuredClone

Created: 2 months ago by: Guest

Jump to the latest result

Lodash CloneDeep

Json Clone

recursiveDeepCopy

structuredClone

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 2 months ago):