Benchmark: lodash cloneDeep vs. structuredClone vs. recursiveDeepCopy

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.21/lodash.min.js'></script>
<script src='https://cdn.jsdelivr.net/npm/jsondiffpatch@0.4.1/dist/jsondiffpatch.umd.min.js'></script>
<script src='https://cdn.jsdelivr.net/npm/rfdc@1.3.0'></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;

var rfdcClone = rfdc();

///////////////////////////////////////////////////////////////////
function recursiveDeepCopy(value) {
  if (value instanceof Date) {
    return new Date(value);
  }
  if (value instanceof RegExp) {
    return new RegExp(value);
  }
  if (value instanceof Map) {
    return new Map(value);
  }
  if (value instanceof Set) {
    return new Set(value);
  }
  if (typeof value !== 'object') {
    return value;
  }
  if (!value) {
    return value;
  }
  let newObject;
  if ('[object Array]' === Object.prototype.toString.apply(value)) {
    newObject = [];
    for (let i = 0; i < value.length; i += 1) {
      newObject[i] = recursiveDeepCopy(value[i]);
    }
    return newObject;
  }

  newObject = {};
  for (let i in value) {
    if (value.hasOwnProperty(i)) {
      newObject[i] = recursiveDeepCopy(value[i]);
    }
  }
  return newObject;
}

Tests:

lodash cloneDeep
myCopy = _.cloneDeep(MyObject);
JSON.parse(JSON.stringify())
myCopy = JSON.parse(JSON.stringify(MyObject));
recursiveDeepCopy
myCopy = recursiveDeepCopy(MyObject);
structuredClone
myCopy = structuredClone(MyObject);
rfdc
myCopy = rfdcClone(MyObject);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash cloneDeep
JSON.parse(JSON.stringify())
recursiveDeepCopy
structuredClone
rfdc

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 20 hours ago)

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

Browser/OS: Chrome 133 on Linux

View result in a separate tab

Test name	Executions per second
lodash cloneDeep	1025617.1 Ops/sec
JSON.parse(JSON.stringify())	873243.7 Ops/sec
recursiveDeepCopy	3573713.8 Ops/sec
structuredClone	405902.2 Ops/sec
rfdc	4297615.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):

LLMs can make mistakes. Check important info.

The benchmark defined in the provided JSON measures the performance of different methods for creating deep copies of a JavaScript object. Here’s an explanation of the various approaches tested, including their pros and cons.

### Options Compared

1. **Lodash `cloneDeep`**
   - **Syntax:** `myCopy = _.cloneDeep(MyObject);`
   - **Library:** Lodash is a popular JavaScript utility library that provides helpful functions for common programming tasks. `cloneDeep` from Lodash is specifically designed to create a deep clone of an object, handling complex data structures such as nested objects and arrays.
   - **Pros:**
     - Handles a wide variety of data types (including arrays, objects, dates, and more) with little code needed.
     - Well-tested and widely used, which reduces the risk of edge cases.
   - **Cons:**
     - Introduces a dependency on the Lodash library, which can increase the size of your application.
     - Performance might not be optimal for every use case, especially compared to some simpler methods.

2. **JSON Stringify/Parse**
   - **Syntax:** `myCopy = JSON.parse(JSON.stringify(MyObject));`
   - **Description:** This is a common technique for creating a deep clone using JSON serialization.
   - **Pros:**
     - Simple and does not rely on external libraries.
     - Works for simple, serializable objects.
   - **Cons:**
     - Does not correctly handle non-serializable values like functions, `undefined`, `Date`, `Map`, `Set`, etc.
     - Can lead to loss of data if the object contains complex types.

3. **Recursive Deep Copy**
   - **Syntax:** `myCopy = recursiveDeepCopy(MyObject);`
   - **Implementation:** This is a custom implementation that recursively copies each property of the object.
   - **Pros:**
     - Highly customizable and can be tailored to specific needs, allowing fine control over what gets copied and how.
     - Can handle diverse data types, although edge cases must be managed manually.
   - **Cons:**
     - More complex and error-prone compared to built-in solutions.
     - Performance may vary based on the depth and structure of the object, and lacks optimizations found in libraries like Lodash.

4. **Structured Clone**
   - **Syntax:** `myCopy = structuredClone(MyObject);`
   - **Description:** `structuredClone` is a built-in method introduced in modern browsers to create deep copies of objects. 
   - **Pros:**
     - Native implementation, which means there is no additional library to include.
     - Supports a wide variety of data types including complex objects (Date, Map, Set, etc.).
   - **Cons:**
     - May not be available in all browsers or environments yet, especially older ones, limiting its use in some situations.
     - There may be performance trade-offs compared to specialized libraries for some scenarios.

5. **RFDC (Really Fast Deep Clone)**
   - **Syntax:** `myCopy = rfdcClone(MyObject);`
   - **Library:** RFDC is a lightweight, fast library specifically designed for deep cloning.
   - **Pros:**
     - Optimized for performance, making it one of the fastest options for deep cloning.
     - Minimalistic, which keeps the bundle size down.
   - **Cons:**
     - Though it handles most built-in types well, it might not cover every edge case like a comprehensive library (e.g., Lodash).
     - Requires an additional library, but is less heavy compared to Lodash.

### Benchmark Results

From the benchmark results, we see the following `ExecutionsPerSecond` rates for each method:
- **rfdc:** 6,468,581.5
- **recursiveDeepCopy:** 5,341,361.0
- **lodash cloneDeep:** 1,845,975.625
- **JSON.parse(JSON.stringify()):** 1,586,476.0
- **structuredClone:** 747,519.0

### Summary of Alternatives

In summary, developers have several options for deep cloning objects in JavaScript, each with varying pros and cons:
- **Lodash `cloneDeep`:** Great for general use; possible dependency concern.
- **JSON methods:** Simple but not suitable for all data types.
- **Custom implementations:** Can be tailored but require maintenance and may lack efficiency.
- **Structured Clone:** Built-in and versatile but potentially less supported.
- **RFDC:** High performance and lightweight; requires third-party library inclusion.

Choosing the right method depends on the specific requirements of the application, including the types of data being cloned and performance considerations.

Related benchmarks:

lodash cloneDeep vs. structuredClone vs. recursiveDeepCopy (version: 1)

Comparing performance of: lodash cloneDeep vs JSON.parse(JSON.stringify()) vs recursiveDeepCopy vs structuredClone vs rfdc

Created: one month ago by: Guest

Jump to the latest result

lodash cloneDeep

JSON.parse(JSON.stringify())

recursiveDeepCopy

structuredClone

rfdc

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