Benchmark: deep copy - MeasureThat.net

HTML Preparation code:

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

Script Preparation code:

var testobject = {
  a: 1,
  b: {
    a: 1,
    b: 2,
    c: {
      a: 1,
      b: [1, 2, 3]
    }
  }
}

Tests:

lodash deepCopy
const copy = _.cloneDeep(testobject)
JSON stringify and parse
const copy = JSON.parse(JSON.stringify(testobject))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash deepCopy
JSON stringify and parse

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Linux; arm_64; Android 12; SM-N970F) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/98.0.4758.102 YaBrowser/22.3.1.86.00 SA/3 Mobile Safari/537.36

Browser/OS: Yandex Browser 22 on Android

View result in a separate tab

Test name	Executions per second
lodash deepCopy	164422.4 Ops/sec
JSON stringify and parse	154966.1 Ops/sec

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

LLMs can make mistakes. Check important info.

Measuring the performance of JavaScript microbenchmarks like this one is crucial to understand how different approaches affect the execution speed.

The provided JSON benchmark definition represents two test cases for comparing deep copying methods:

1.  **Lodash Deep Copy:** The first test case uses the `lodash.cloneDeep` function, which is a utility function from the Lodash library. This library provides various high-order functions that help in functional programming and data manipulation. In this specific case, it's used to create a deep copy of an object.

*   Pros:

*   **Efficient:** `lodash.cloneDeep` is implemented using a recursive approach with memoization, which ensures that the same objects are only cloned once.
        *   **Robust:** It handles complex data structures like nested arrays and objects, making it a reliable choice for deep copying.

*   Cons:

*   **Dependency on Lodash:** This method relies on the Lodash library, which may introduce additional overhead due to the need to load the library's code.
        *   **Size of cloned object:** Although `lodash.cloneDeep` is efficient, it still creates a new object with references to the original properties. This can lead to increased memory usage.

2.  **JSON Stringify and Parse:** The second test case uses the built-in JavaScript method `JSON.parse(JSON.stringify(testobject))`. This approach stringifies the input object using `JSON.stringify` and then parses it back into an object using `JSON.parse`.

*   Pros:

*   **Native Functionality:** Using native JavaScript functions eliminates any dependency on external libraries, potentially reducing overhead.
        *   **Simple Implementation:** The implementation is straightforward and easy to understand.

*   Cons:

*   **Performance Overhead:** Stringifying and parsing JSON can be slower than using a specialized library like Lodash for deep copying. This is because it involves additional overhead, such as encoding and decoding data.

**Special JS Feature/Syntax:**

Neither of the provided test cases uses any special JavaScript features or syntax. The focus remains on comparing different deep copying methods implemented in JavaScript.

**Other Alternatives:**

If you're looking for alternative approaches to deep copying in JavaScript, here are a few more options:

1.  **Manual Recursive Approach:** You can create your own recursive function that traverses the object and creates new copies of its properties.
2.  **Using `Object.assign()` and Loops:** Another approach is to use `Object.assign()` to create a shallow copy of an object, and then iterate over its properties using loops to create deep copies of nested objects.

Here's a basic example of how you could implement the manual recursive approach:

```javascript
function manualDeepCopy(obj) {
    const result = {};

for (const key in obj) {
        if (typeof obj[key] === 'object' && obj[key] !== null) {
            result[key] = manualDeepCopy(obj[key]);
        } else {
            result[key] = obj[key];
        }
    }

return result;
}
```

Keep in mind that this approach is more verbose and may be less efficient than using a specialized library like Lodash.

In summary, the choice of deep copying method depends on the specific use case, performance requirements, and personal preference.

Related benchmarks:

deep copy (version: 0)

Comparing performance of: lodash deepCopy vs JSON stringify and parse

Created: 4 years ago by: Guest

Jump to the latest result

lodash deepCopy

JSON stringify and parse

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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