Benchmark: _.merge vs Object.assign

HTML Preparation code:

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

Script Preparation code:

var obj1 = { adalet: false }
var obj2 = { barış: false }
var obj3 = { özgürlük: false }

Tests:

Lodash
_.merge({}, obj1, obj2, obj3)
Native
Object.assign({}, obj1, obj2, obj3)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash
Native

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 7 months ago)

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

Browser/OS: Yandex Browser 25 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Lodash	5577792.5 Ops/sec
Native	22073984.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of MeasureThat.net and explore what's being tested in this benchmark.

**Benchmark Overview**

The benchmark compares two approaches for merging objects: Lodash's `_merge` function and the native `Object.assign` method.

**Options Compared**

The test cases compare:

1. **Lodash's `_merge` function**: A utility function from the popular JavaScript library Lodash that merges multiple objects into a single object.
2. **Native `Object.assign` method**: A built-in JavaScript method for merging two or more objects into a new object.

**Pros and Cons**

Here are some pros and cons of each approach:

* **Lodash's `_merge` function**:
	+ Pros:
		- Can handle nested objects with ease.
		- Can be customized to use specific merge strategies (e.g., merging multiple properties, handling undefined values).
	+ Cons:
		- Adds an external dependency on the Lodash library, which may introduce overhead.
* **Native `Object.assign` method**:
	+ Pros:
		- Built-in and widely supported across browsers and Node.js environments.
		- Faster execution time compared to Lodash's `_merge` function (although not always significant).
	+ Cons:
		- Can be slower for complex object merges due to the need to create a new object with all the properties from each input object.

**Other Considerations**

* **Library Usage**: The benchmark uses Lodash, which is a popular utility library for JavaScript. This choice may introduce some overhead due to the additional dependency.
* **Browser Support**: Both approaches are supported by most modern browsers, but it's essential to ensure compatibility with older browsers if necessary.
* **Performance**: The execution time of each approach can vary depending on the size and complexity of the input objects.

**Individual Test Cases**

The individual test cases measure the performance of each approach:

1. `_merge` function: `_.merge({}, obj1, obj2, obj3)`
This test case uses Lodash's `_merge` function to merge three simple objects (`obj1`, `obj2`, and `obj3`) into a single object.
2. Native `Object.assign` method: `Object.assign({}, obj1, obj2, obj3)`
This test case uses the native `Object.assign` method to achieve the same result as Lodash's `_merge` function.

**Conclusion**

The MeasureThat.net benchmark provides valuable insights into the performance differences between using an external library (Lodash) and a built-in JavaScript method (Object.assign). Understanding these trade-offs can help developers make informed decisions when working with object merges in their projects.

Related benchmarks:

_.merge vs Object.assign (version: 0)

Comparing performance of: Lodash vs Native

Created: 7 years ago by: Guest

Jump to the latest result

Lodash

Native

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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