Benchmark: mergeDeepRight vs _.cloneDeep vs structuredClone vs spread v2

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.29.0/ramda.min.js" integrity="sha512-5x/n+aOg68Z+O/mq3LW2pC2CvEBSgLl5aLlOJa87AlYM1K8b8qsZ7NTHLe3Hu56aS2W0rgEgVCFA3RM12IXAGw==" crossorigin="anonymous" referrerpolicy="no-referrer"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.21/lodash.min.js" integrity="sha512-WFN04846sdKMIP5LKNphMaWzU7YpMyCU245etK3g/2ARYbPK9Ub18eG+ljU96qKRCWh+quCY7yefSmlkQw1ANQ==" crossorigin="anonymous" referrerpolicy="no-referrer"></script>

Script Preparation code:

var voucher = {
    "single": false,
    "applyOverTaxes": false,
    "discountType": "1",
    "value": 100,
    "minimumAmount": 0,
    "quantity": 1,
    "suffixLength": 8,
    "code": "IF5R0AFX",
    "vertical": [],
    "allowedPaymentMethods": [],
    "allowedBanks": [],
    "types": [],
    "partners": [],
    "startDate": "2020-10-21T00:00:00.000Z",
    "endDate": "2020-10-21T00:00:00.000Z",
    "applyed": false
}

Tests:

R.mergeDeepRight
const copy = R.mergeDeepRight({}, voucher);
Lodash cloneDeep
const copy = _.cloneDeep(voucher);
structuredClone
const copy = window.structuredClone(voucher);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
R.mergeDeepRight
Lodash cloneDeep
structuredClone

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 13 days ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36

Browser/OS: Chrome 131 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
R.mergeDeepRight	2447150.2 Ops/sec
Lodash cloneDeep	630259.2 Ops/sec
structuredClone	643940.7 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 13 days ago):

LLMs can make mistakes. Check important info.

The benchmark defined in the provided JSON tests the performance of different methods for creating deep clones of a JavaScript object, specifically comparing the following approaches:

1. **R.mergeDeepRight** from the Ramda library.
2. **_.cloneDeep** from the Lodash library.
3. **structuredClone**, a built-in JavaScript method introduced in modern browsers.

### Options Compared

1. **R.mergeDeepRight**
   - **Library**: Ramda (a functional programming library for JavaScript)
   - **Description**: The `R.mergeDeepRight` function creates a new object by merging properties from a source object into a target object recursively. If the same property exists in both objects, the value from the source object takes precedence.
   - **Pros**: 
     - Functional programming style — does not mutate the original objects.
     - Handles deep merging, which is essential for nested objects.
   - **Cons**: 
     - Might be slower than native solutions due to overhead from function calls and handling immutable data.

2. **_.cloneDeep**
   - **Library**: Lodash (a widely used utility library providing many functions to simplify JavaScript programming)
   - **Description**: The `_.cloneDeep` method creates a deep copy of the value (cloning all levels of nested objects).
   - **Pros**: 
     - Well-optimized and widely accepted in the JavaScript community.
     - Compatible with a wide range of data types (including arrays and dates).
   - **Cons**:
     - Potentially larger bundle size if Lodash is extensively used.
     - Slightly more complex from a dependency management perspective since it requires an external library.

3. **structuredClone**
   - **Description**: `structuredClone` is a native method that creates a deep clone of a value, supporting many complex types (like Date, Set, Map, etc.) that most shallow copying methods do not handle.
   - **Pros**:
     - Built-in and does not require additional libraries.
     - High performance for cloning complex data structures.
   - **Cons**:
     - Compatibility can be an issue as it is only available in modern browsers and JavaScript environments.
     - Not all types are cloneable (e.g., certain objects like functions).

### Benchmark Results

The results show the number of executions per second, demonstrating the performance difference among the methods:

- **R.mergeDeepRight**: 2,447,150.25 executions/sec — the fastest in this benchmark.
- **structuredClone**: 643,940.6875 executions/sec — a significant but not surprising drop considering the potential overhead of handling different types.
- **Lodash cloneDeep**: 630,259.1875 executions/sec — similar performance to structuredClone but slower than the Ramda approach.

### Considerations

- **Performance vs. Flexibility**: While `R.mergeDeepRight` shows the best performance in this specific benchmark, the actual choice of cloning method should depend on the requirements of the implementation, such as compatibility and handling of complex data structures.
- **Library Dependencies**: Using a library like Lodash or Ramda may introduce additional weight to the application if only one or two functions are needed. In contrast, native solutions like `structuredClone` help reduce dependencies.
- **Future-proofing**: As JavaScript evolves, built-in methods may become more efficient, pushing third-party libraries into the background.

### Alternatives

Apart from the mentioned methods, developers could explore several alternatives for deep cloning, including:

1. **JSON Serialization**: Using `JSON.parse(JSON.stringify(object))` can be a quick way to clone objects, but it has limitations, such as not handling functions, undefined values, and special objects like Date.
   
2. **Manual Deep Clone Implementation**: Developers can write custom functions tailored to specific structure needs, although this can lead to maintenance challenges and bugs if not carefully implemented.

3. **Other Libraries**: Libraries like Immer or deepmerge provide alternative approaches to deep cloning and merging, emphasizing immutability and functional programming practices.

In summation, the choice of deep cloning method should consider factors such as performance, compatibility with complex object types, library dependencies, and the specific use cases in your application.

Related benchmarks:

mergeDeepRight vs _.cloneDeep vs structuredClone vs spread v2 (version: 1)

Comparing performance of: R.mergeDeepRight vs Lodash cloneDeep vs structuredClone

Created: 13 days ago by: Guest

Jump to the latest result

R.mergeDeepRight

Lodash cloneDeep

structuredClone

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 13 days ago):