Benchmark: lodash merge vs deepmerge vs lodash/fp merge

HTML Preparation code:


<script src='https://cdn.jsdelivr.net/g/lodash@4(lodash.min.js+lodash.fp.min.js)'></script>
<script src='https://unpkg.com/deepmerge@3.2.0/dist/umd.js'></script>

Script Preparation code:

var fp = _.noConflict();

Tests:

lodash merge
var a = { a: 'oh', b: 'my', c: { a: 'a', b: { c: 'c' } } }; var b = { c: { b: { d: 'a' }, c: { d: 'd' } } }; var c = _.merge({}, a, b);
object.assign
var a = { a: 'oh', b: 'my', c: { a: 'a', b: { c: 'c' } } }; var b = { c: { b: { d: 'a' }, c: { d: 'd' } } }; var c = deepmerge({}, a, b);
lodash/fp merge
var a = { a: 'oh', b: 'my', c: { a: 'a', b: { c: 'c' } } }; var b = { c: { b: { d: 'a' }, c: { d: 'd' } } }; var c = fp.merge(b, a);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash merge
object.assign
lodash/fp merge

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

**What is tested?**

On MeasureThat.net, users can create and run JavaScript microbenchmarks to compare different approaches for merging objects. The benchmark tests three popular libraries: Lodash, Deepmerge, and Lodash/FP (Functional Programming).

The individual test cases demonstrate how each library merges two objects, `a` and `b`, using the following syntax:

```javascript
var a = { a: 'oh', b: 'my', c: { a: 'a', b: { c: 'c' } } };
var b = { c: { b: { d: 'a'  }, c: { d: 'd' } } };
```

The test cases are:

1. Lodash `_.merge()`: `var c = _.merge({}, a, b);`
2. Object.assign: `var c = object.assign({}, a, b);` (not explicitly shown in the benchmark code, but implied)
3. Lodash/FP `fp.merge()`: `var c = fp.merge(b, a);`

**Options compared**

The benchmark compares three different approaches for merging objects:

1. **Lodash (`_.merge()`)**: Lodash is a utility library that provides a wide range of functions for manipulating data, including object merging. The `_merge()` function takes multiple arguments and returns a new object with the merged properties.
2. **Object.assign**: This is a built-in JavaScript method that allows you to copy properties from one or more source objects into a target object.
3. **Lodash/FP (`fp.merge()`)**: Lodash/FP is a functional programming variant of Lodash, which provides a different set of functions for manipulating data.

**Pros and Cons**

Here's a brief summary of the pros and cons of each approach:

1. **Lodash (`_.merge()`)**:
	* Pros: widely supported, flexible, and extensible.
	* Cons: can be slower than other approaches due to its overhead.
2. **Object.assign**:
	* Pros: built-in JavaScript method, fast, and lightweight.
	* Cons: limited functionality compared to Lodash's `_.merge()`.
3. **Lodash/FP (`fp.merge()`)**:
	* Pros: functional programming approach, concise code.
	* Cons: may be less familiar or intuitive for developers without prior experience.

**Library explanations**

1. **Deepmerge**: Deepmerge is a lightweight library that provides a simple and efficient way to merge objects. It's designed to be fast and flexible, making it suitable for various use cases.
2. **Lodash**: Lodash is a comprehensive utility library that provides a wide range of functions for manipulating data. Its `_.merge()` function is an essential part of the library.

**Special JS features**

The benchmark doesn't explicitly mention any special JavaScript features or syntax. However, it's worth noting that some of these libraries (e.g., Lodash) might require additional setup or configuration, such as importing dependencies using ES modules or commonJS.

**Alternatives**

Other alternatives for merging objects in JavaScript include:

1. **ES6 Object Spread Operator (`{ ...a, ...b }`)**: This is a shorthand way to merge two objects using the spread operator.
2. **JSON Merge Patch**: This library provides a simple and efficient way to merge JSON objects.

In conclusion, MeasureThat.net's benchmark allows users to compare different approaches for merging objects in JavaScript, providing valuable insights into their performance characteristics. By understanding the pros and cons of each approach, developers can make informed decisions about which solution best suits their specific use case.

Latest run results:

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

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

Browser/OS: Chrome 125 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
lodash merge	641677.8 Ops/sec
object.assign	3327077.2 Ops/sec
lodash/fp merge	520416.3 Ops/sec

Related benchmarks:

lodash merge vs deepmerge vs lodash/fp merge (version: 0)

Comparing performance of: lodash merge vs object.assign vs lodash/fp merge

Created: 4 years ago by: Guest

Jump to the latest result

lodash merge

object.assign

lodash/fp merge

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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