Benchmark: lodash deep merge vs object.assign vs spread

HTML Preparation code:

<script src='https://cdn.jsdelivr.net/npm/lodash@4.17.21/lodash.min.js'></script>

Tests:

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

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash merge
object.assign
spread

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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 JavaScript microbenchmarks!

**Overview**

The provided JSON represents a benchmark test created on MeasureThat.net. The benchmark tests three approaches for merging objects in JavaScript: `lodash.merge`, `object.assign`, and the spread operator (`{ ...a, ...b }`).

**What is being tested?**

Each test case is designed to measure the performance of each approach when merging two objects.

* `var a = { a: 'oh', b: 'my' };\r\nvar b = { c: 'goddess', d: {d: 'deep'}};\r\nvar c = _.merge(a, b);`: This test case uses the `_` variable to access the Lodash library, which provides the `merge()` function.
* `var a = { a: 'oh', b: 'my' };\r\nvar b = { c: 'goddess', d: {d: 'deep'}};\r\nvar c = Object.assign(a, b);`: This test case uses the built-in `Object.assign()` method.
* `var a = { a: 'oh', b: 'my' };\r\nvar b = { c: 'goddess', d: {d: 'deep'}};\r\nvar c = { ...a, ...b };`: This test case uses the spread operator (`{ ...a, ...b }`) to merge the two objects.

**Options compared**

The benchmark compares three options for merging objects:

1. `_.merge(a, b)` (Lodash library)
2. `Object.assign(a, b)` (built-in JavaScript method)
3. `{ ...a, ...b }` (spread operator)

**Pros and Cons of each approach:**

1. **_lodash.merge()**
	* Pros:
		+ Easy to use
		+ Provides a clear and concise API for merging objects
	* Cons:
		+ Requires an external library (Lodash)
		+ May introduce additional overhead due to the import and execution of the library
2. **Object.assign()**
	* Pros:
		+ Fast and lightweight
		+ Built-in JavaScript method, no external dependencies
	* Cons:
		+ Can be less readable than other methods (e.g., `...` spread operator)
		+ Limited to objects with enumerable properties
3. **{ ...a, ...b }**
	* Pros:
		+ Fast and lightweight
		+ Readable and concise syntax
		+ Built-in JavaScript method
	* Cons:
		+ Only works with objects that support the spread operator (ECMAScript 2015+)

**Special JS feature or syntax**

The benchmark uses the ES6 spread operator (`{ ...a, ...b }`) in the third test case. This operator allows for concise merging of objects by spreading the properties from one object onto another.

**Other alternatives**

In addition to these three approaches, other methods for merging objects include:

* `Object.create()` and `Object.assign()`
* `Object.keys().reduce()`
* Using a custom loop or recursive function

These alternatives may offer different trade-offs in terms of performance, readability, and maintainability. However, they are not included in the benchmark as part of the original test cases.

Related benchmarks:

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

Comparing performance of: lodash merge vs object.assign vs spread

Created: 2 years ago by: Guest

Jump to the latest result

lodash merge

object.assign

spread

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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