Benchmark: lodash merge vs object.assign vs object.assign (no overwrite) vs spread

HTML Preparation code:

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

Tests:

lodash merge
var a = { a: 'oh', b: 'my' }; var b = { c: 'goddess' }; var c = _.merge(a, b);
object.assign
var a = { a: 'oh', b: 'my' }; var b = { c: 'goddess' }; var c = Object.assign(a, b);
spread
var a = { a: 'oh', b: 'my' }; var b = { c: 'goddess' }; var c = { ...a, ...b };
assign (no overwrite)
var a = { a: 'oh', b: 'my' }; var b = { c: 'goddess' }; var c = Object.assign({}, a, b);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash merge
object.assign
spread
assign (no overwrite)

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**Overview**

The provided JSON represents a JavaScript benchmark test case on the MeasureThat.net website. The goal of this benchmark is to compare the performance of different methods for merging two objects in JavaScript.

**Method Comparison**

Four methods are compared:

1.  **Lodash `merge`**: This method uses the Lodash library to merge two objects. It returns a new object with merged properties from both input objects.
2.  **`Object.assign`**: This method is used to assign values from one or more source objects to a target object. It returns the target object with assigned properties.
3.  **Spread Operator (`...`)**: This operator creates a new object by spreading properties from an existing object(s) into a new object. In this test, it's used to merge two objects.
4.  **`Object.assign` (no overwrite)**: Similar to the previous method but with an additional check to prevent overwriting properties in the target object.

**Pros and Cons**

1.  **Lodash `merge`**: Pros:
    *   More concise syntax
    *   Handles nested objects and arrays
    *   Reduces code duplication
2.  **`Object.assign`**: Pros:
    *   Native support, no external library required
    *   Fast performance
    *   Simple to use
3.  **Spread Operator (`...`)**: Pros:
    *   Simplifies object merging and creates a new object
4.  **`Object.assign (no overwrite)`**: Pros:
    *   Prevents overwriting properties in the target object

Cons:

*   **Lodash `merge`**:
    *   Requires an external library, adding overhead
    *   Less performant compared to native methods
*   **`Object.assign`**:
    +   Can be slow for large objects or deeply nested ones.
*   **Spread Operator (`...`)**:
    +   Only works with objects and not arrays.
    +   No control over property keys or values.

**Library Usage**

The `lodash.merge` method is the only one that uses an external library (Lodash). This adds a small overhead due to library initialization and parsing. However, it simplifies the code and makes object merging more concise.

**JavaScript Features**

No special JavaScript features are used in this benchmark test case.

**Alternative Approaches**

Some alternative approaches for merging objects include:

*   Using `concat` method with arrays
*   Creating a new object using a constructor function (e.g., `Object.create()` or a custom class)
*   Using `JSON.parse(JSON.stringify(obj1, obj2))`
*   Utilizing libraries like ` deepmerge` or ` merge-deep`

Keep in mind that these alternatives may have different performance characteristics and might not be as straightforward to use.

**Performance Considerations**

In terms of performance, the benchmark results show that:

*   **Lodash `merge`**: The slowest method, likely due to the external library overhead.
*   **`Object.assign (no overwrite)`**: Faster than `Object.assign`, possibly because it avoids the native object lookup and copying process for property keys.
*   **Spread Operator (`...`)**: Similar performance to `Object.assign`, with a slight advantage due to its conciseness and simplicity.

**Conclusion**

The choice of method ultimately depends on your specific use case, personal preference, or project requirements. The MeasureThat.net benchmark provides an excellent starting point for exploring object merging in JavaScript.

Latest run results:

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

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

Browser/OS: Chrome 106 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
lodash merge	3466734.0 Ops/sec
object.assign	6491242.0 Ops/sec
spread	2533773.5 Ops/sec
assign (no overwrite)	5100183.0 Ops/sec

Related benchmarks:

lodash merge vs object.assign vs object.assign (no overwrite) vs spread (version: 0)

Comparing performance of: lodash merge vs object.assign vs spread vs assign (no overwrite)

Created: 5 years ago by: Guest

Jump to the latest result

lodash merge

object.assign

spread

assign (no overwrite)

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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