Benchmark: lodash merge vs deepmerge vs ramda

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.21/lodash.min.js'></script>
<script src='https://unpkg.com/deepmerge@4.2.2/dist/umd.js'></script>
<script src="//cdn.jsdelivr.net/npm/ramda@latest/dist/ramda.min.js"></script>

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);
deepmerge
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);
ramda
var a = { a: 'oh', b: 'my', c: { a: 'a', b: { c: 'c' } } }; var b = { c: { b: { d: 'a' }, c: { d: 'd' } } }; var c = R.mergeDeepRight(a, b)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash merge
deepmerge
ramda

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Measuring JavaScript performance is an essential task, and BenchmarkThat.net provides a great platform for doing so. Let's dive into the provided benchmark definition and explain what's being tested.

**Benchmark Definition**

The benchmark consists of three test cases:

1. **Lodash Merge**: This test case uses Lodash's `merge` function to merge two objects, `a` and `b`. The `merge` function is used with an empty object as the first argument.
2. **DeepMerge**: This test case uses DeepMerge's `merge` function to perform a deep merge of two objects, `a` and `b`.
3. **Ramda Merge**: This test case uses Ramda's `R.mergeDeepRight` function to perform a deep merge of two objects, `a` and `b`.

**Options Being Compared**

In each test case, the same input objects (`a` and `b`) are used, but the functions being tested (Lodash `merge`, DeepMerge `merge`, Ramda `R.mergeDeepRight`) differ in their approach to merging the objects.

Here's a brief overview of each function:

* **Lodash Merge**: This function performs a shallow merge of two objects. It only iterates over the properties of the first object (`a`) and updates them with values from the second object (`b`). If a property exists in both objects, its value will be overwritten.
* **DeepMerge**: This function performs a deep merge of two objects. It recursively iterates over the properties of both objects, creating new nested objects as needed to ensure that all properties are present in the merged result.
* **Ramda Merge**: This function also performs a deep merge of two objects. However, it uses a more functional programming approach, using `R.mergeDeepRight` to merge the right-hand object (`b`) into the left-hand object (`a`).

**Pros and Cons**

Each function has its strengths and weaknesses:

* **Lodash Merge**: Fast and efficient for shallow merges, but may not work correctly for deeply nested objects.
* **DeepMerge**: More robust and flexible than Lodash `merge`, but may be slower due to the additional complexity of the merge process.
* **Ramda Merge**: Provides a more functional programming approach, which can lead to more concise code, but may also introduce performance overhead.

**Library Descriptions**

1. **Lodash**: A utility library for JavaScript that provides a wide range of functions for tasks such as array manipulation, string manipulation, and object manipulation.
2. **DeepMerge**: A library specifically designed for performing deep merges of objects in JavaScript.
3. **Ramda**: A functional programming library for JavaScript that provides a set of immutable functions for manipulating data.

**Special JS Features/Syntax**

No special JS features or syntax are used in these test cases, apart from the use of object literals and method calls (`_.merge`, `R.mergeDeepRight`).

**Other Alternatives**

If you're interested in benchmarking other JavaScript merge libraries or functions, here are a few alternatives:

* **UglifyJS-Merge**: A JavaScript library for merging objects that's part of the UglifyJS project.
* **js-migrate-merge**: A lightweight JavaScript library for merging objects.
* **merge-deep**: Another JavaScript library for performing deep merges of objects.

Keep in mind that each library has its own strengths and weaknesses, and may not be suitable for all use cases.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:132.0) Gecko/20100101 Firefox/132.0

Browser/OS: Firefox 132 on Mac OS X 10.15

View result in a separate tab

Test name	Executions per second
lodash merge	727580.8 Ops/sec
deepmerge	673010.1 Ops/sec
ramda	1406336.8 Ops/sec

Related benchmarks:

lodash merge vs deepmerge vs ramda (version: 0)

Comparing performance of: lodash merge vs deepmerge vs ramda

Created: 3 years ago by: Guest

Jump to the latest result

lodash merge

deepmerge

ramda

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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