Benchmark: Lodash deeper clone vs Spread Clone

HTML Preparation code:

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

Script Preparation code:

window.obj = { foo: 'some string', bar: 'another', subObj: { hey: 'you', what: 'are you doing', ahey: 'you', bhey: 'you', chey: 'you', dhey: 'you', ehey: 'you', fhey: 'you', ghey: 'you' } }

Tests:

Lodash deep clone
const objClone = _.cloneDeep(window.obj);
Spread
const objClone = {...window.obj};

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash deep clone
Spread

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.212 Safari/537.36

Browser/OS: Chrome 90 on Windows

View result in a separate tab

Test name	Executions per second
Lodash deep clone	132304.2 Ops/sec
Spread	1684362.9 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the Benchmark Definition and explore what is being tested, the options compared, their pros and cons, and other considerations.

**Benchmark Definition:**

The benchmark measures the performance difference between two methods of cloning an object:

1. **Lodash Deep Clone**: Uses the `_.cloneDeep()` function from the Lodash library to create a deep copy of the original object.
2. **Spread Clone**: Uses the syntax `{...obj}` to create a shallow copy of the original object.

**Options Compared:**

*   **Lodash Deep Clone**: Creates a deep copy of the object, which means that all nested objects and arrays are recursively cloned as well.
*   **Spread Clone**: Creates a shallow copy of the object, which means that only the top-level properties are copied, and any nested objects or arrays are left unchanged.

**Pros and Cons:**

*   **Lodash Deep Clone**:
    *   Pros:
        *   Ensures accurate and complete copying of nested objects and arrays.
        *   Can handle complex data structures with multiple levels of nesting.
    *   Cons:
        *   Requires the Lodash library, which may add extra overhead.
        *   May be slower due to the recursive cloning process.
*   **Spread Clone**:
    *   Pros:
        *   Faster and more efficient than deep cloning, as it only copies the top-level properties.
        *   Does not require an additional library.
    *   Cons:
        *   May not work correctly for nested objects or arrays, as they are left unchanged.

**Library:**

In this benchmark, Lodash is used as a third-party library to provide the `_.cloneDeep()` function. The library's purpose is to offer a utility function that can be used to create deep copies of objects and arrays in JavaScript.

**Special JS Feature/Syntax:**

There are no special JavaScript features or syntaxes being tested in this benchmark. However, it's worth noting that the spread clone method relies on the `...` operator, which was introduced in ECMAScript 2018 (ES2018).

**Other Alternatives:**

If you're interested in exploring alternative methods for cloning objects, here are a few options:

*   **JSON.parse(JSON.stringify(obj))**: This method creates a shallow copy of the object by serializing it to a JSON string and then parsing that string back into an object.
*   **Array.prototype.slice()**: If you're working with arrays, you can use `Array.prototype.slice()` to create a shallow copy of the array.

Keep in mind that these alternatives may have different performance characteristics or behavior compared to the Lodash deep clone and spread clone methods.

Related benchmarks:

Lodash deeper clone vs Spread Clone (version: 0)

Comparing performance of: Lodash deep clone vs Spread

Created: 3 years ago by: Guest

Jump to the latest result

Lodash deep clone

Spread

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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