Benchmark: Comparing deep cloning methods (small object): Lodash <> Custom clone func <> JSON.parse <> structuredClone 2

HTML Preparation code:

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

Script Preparation code:

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

Lodash
myCopy = _.cloneDeep(MyObject);
Custom function
myCopy = recursiveDeepCopy(MyObject);
JSON.parse
myCopy = JSON.parse(JSON.stringify(MyObject));
structuredClone
myCopy = structuredClone(MyObject);
simple
myCopy = {...MyObject}

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash
Custom function
JSON.parse
structuredClone
simple

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 25 days ago):

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested.

**Benchmark Definition JSON**

The benchmark defines a set of test cases to compare different approaches for creating a deep clone of an object. The object, `MyObject`, is defined with various properties, including a nested object `jayson`. This object contains two relevant properties: `stringify` and `parse`, which are related to the JSON serialization and deserialization process.

**Test Cases**

There are five test cases:

1. **Lodash**: Uses the `_cloneDeep` function from the Lodash library to create a deep clone of `MyObject`.
2. **Custom Function**: Implements a custom function, `recursiveDeepCopy`, to create a deep clone of `MyObject`.
3. **JSON.parse**: Attempts to create a deep clone by parsing the JSON representation of `MyObject` using `JSON.stringify` and then parsing the result back into an object.
4. **structuredClone**: Uses the `structuredClone` function, introduced in modern browsers (including Safari 15), to create a deep clone of `MyObject`.
5. **Simple**: Creates a shallow copy of `MyObject` by simply using the spread operator (`{...}`).

**Options Comparison**

The test cases compare the performance of different approaches:

*   **Lodash vs Custom Function**: Lodash is generally faster and more efficient due to its optimized implementation, while the custom function requires manual iteration and branching.
*   **JSON.parse vs structuredClone**: `structuredClone` is designed for deep cloning objects and is likely to be faster than using `JSON.parse`. This is because `structuredClone` avoids the need to serialize and deserialize the object, whereas `JSON.parse` involves converting the object to a string, parsing it, and then converting it back to an object.
*   **Custom Function vs structuredClone**: The custom function requires manual implementation of recursive copying, while `structuredClone` is a built-in function optimized for deep cloning objects.

**Pros and Cons**

Here are some pros and cons associated with each approach:

*   **Lodash**:
    *   Pros: Fast, efficient, and well-tested.
    *   Cons: Requires including an additional library (Lodash).
*   **Custom Function**:
    *   Pros: No dependencies, easy to understand for developers familiar with recursion.
    *   Cons: Requires manual implementation of recursive copying, can be slower due to the overhead of function calls.
*   **JSON.parse**:
    *   Pros: Easy to implement, no additional dependencies required.
    *   Cons: Slower than `structuredClone` and Lodash due to serialization and deserialization overhead.
*   **Structured Clone**:
    *   Pros: Fast, efficient, and optimized for deep cloning objects. Available in modern browsers.
    *   Cons: Limited support for older browsers.

**Library Usage**

In this benchmark, the following libraries are used:

*   Lodash (for its `_cloneDeep` function)
*   None (the custom function does not rely on any external libraries)

**Special JavaScript Features**

The benchmark utilizes the `structuredClone` function, which is a relatively new feature introduced in modern browsers. It allows for creating deep clones of objects without requiring serialization and deserialization.

Overall, this benchmark provides insight into the performance differences between various approaches to deep cloning objects in JavaScript, highlighting the trade-offs between using built-in functions like `structuredClone`, Lodash, or implementing custom solutions.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.5 Safari/605.1.15

Browser/OS: Safari 15 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Lodash	501724.5 Ops/sec
Custom function	835661.2 Ops/sec
JSON.parse	529282.7 Ops/sec
structuredClone	433957.3 Ops/sec
simple	3668648.0 Ops/sec

Related benchmarks:

Comparing deep cloning methods (small object): Lodash <> Custom clone func <> JSON.parse <> structuredClone 2 (version: 0)

Missing clone-deep

Comparing performance of: Lodash vs Custom function vs JSON.parse vs structuredClone vs simple

Created: 2 years ago by: Guest

Jump to the latest result

Lodash

Custom function

JSON.parse

structuredClone

simple

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 25 days ago):