Benchmark: cloneDeep VS spread all around

Script Preparation code:

window.sourceO = {
    foo: 42,
    bar: {
        list: [0, 1, 2, 3],
        text: 'hello'
    },
    biz: {
        nest: {
            nest: {
                nest: {
                    a: 42,
                    b: 12
                }
            }
        }
    }
};

Tests:

spread
const copySpread = {...window.sourceO, nest: {nest: {nest: {...window.sourceO.nest.nest.nest, b: 42}}}};
cloneDeep
let copyCloneDeep = _.cloneDeep(window.sourceO); copyCloneDeep.biz.nest.nest.nest.b = 42;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
spread
cloneDeep

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark definition and test cases to understand what is being tested.

**Benchmark Definition**

The benchmark definition is a JSON object that contains two main parts:

1. **Script Preparation Code**: This code defines an object `window.sourceO` with nested properties, including `foo`, `bar`, and `biz`. The `biz` property has another nested object with multiple levels of nesting.
2. **Html Preparation Code**: This field is empty, which means that no HTML preparation code is needed for this benchmark.

**Individual Test Cases**

There are two individual test cases defined:

1. **cloneDeep**: This test case uses the _.cloneDeep() function to clone the `window.sourceO` object. The expected output is a new object with the same properties as `window.sourceO`, but potentially different references.
2. **spread**: This test case uses the spread operator (`...`) to create a new object that includes all properties from `window.sourceO`, but only up to a certain level of nesting (i.e., it skips the innermost `nest` property).

**Options Compared**

The benchmark is comparing two approaches:

1. **_.cloneDeep()**: This method creates a deep copy of the original object, which means it recursively clones all nested properties.
2. **Spread Operator (`...`)**: This operator creates a new object with the same properties as the original object, but potentially different references.

**Pros and Cons**

Here's a brief summary of the pros and cons of each approach:

1. **_.cloneDeep()**:
	* Pros: Creates an exact copy of the original object, which can be useful for debugging or testing purposes.
	* Cons: Can be slower than the spread operator due to its recursive cloning process.
2. **Spread Operator (`...`)**:
	* Pros: Faster than _.cloneDeep() because it only creates shallow copies of nested properties.
	* Cons: May not create exact copies of deeply nested objects, as it skips innermost levels.

**Library and Syntax**

In the test case "cloneDeep", the library used is Underscore.js (`_.cloneDeep()`), which provides a utility function for creating deep copies of objects. The syntax used is JavaScript's object literal notation.

There are no special JS features or syntax used in these test cases, so we can move on to the next section.

**Other Considerations**

When benchmarking these two approaches, it's essential to consider factors like:

* Memory usage: Does the spread operator create more memory overhead than _.cloneDeep()?
* Performance: How do the execution times compare between the two approaches?

**Alternatives**

Some alternative methods for creating copies of objects in JavaScript include:

1. **Object.assign()**: This method creates a shallow copy of an object.
2. **JSON.parse(JSON.stringify(obj))**: This method creates a deep copy of an object by serializing it to JSON and then parsing the resulting string back into an object.

Keep in mind that these alternatives may not provide the exact same results as _.cloneDeep() or the spread operator, depending on your specific use case.

Related benchmarks:

cloneDeep VS spread all around (version: 0)

Comparing performance of: spread vs cloneDeep

Created: 5 years ago by: Guest

Jump to the latest result

spread

cloneDeep

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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