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

Autogenerated LLM Summary (model llama3.2:3b, generated 26 days 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.

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

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 26 days ago):