Benchmark: Lodash merge vs native spread and assign

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' }; var c = _.merge(a, {b});
Native
var a = { a: 'oh', b: 'my' }; var b = { c: 'goddess' }; var c = {...a, b};

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash merge
Native

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36

Browser/OS: Chrome 138 on Windows

View result in a separate tab

Test name	Executions per second
Lodash merge	1726450.6 Ops/sec
Native	60518284.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 JavaScript microbenchmarks on MeasureThat.net.

**What is being tested?**

The provided benchmark measures the performance difference between two approaches for merging objects in JavaScript:

1. **Lodash merge**: The `_.merge()` function from the Lodash library, which recursively merges two or more objects and returns a new object with the merged result.
2. **Native spread and assign**: A native JavaScript approach using the spread operator (`{...a, b}`) to merge two objects.

**Options comparison**

The benchmark compares these two approaches for merging objects. The main difference between them lies in how they handle recursive properties and array merging:

* Lodash merge uses a recursive function to merge objects, which can lead to better performance for complex object structures.
* Native spread and assign uses the spread operator, which creates a new object with the merged result. This approach is generally faster but may not work correctly for nested arrays or complex object structures.

**Pros and Cons**

**Lodash merge:**

Pros:

* Better support for recursive properties and array merging
* More control over the merging process

Cons:

* Slower due to the recursive function call
* Requires an external library (Lodash)

**Native spread and assign:**

Pros:

* Faster execution time
* Native JavaScript implementation, no external dependencies required

Cons:

* Limited support for recursive properties and array merging
* May not work correctly for complex object structures

**Library usage**

The `_.merge()` function from Lodash is used in the benchmark. Lodash is a popular utility library for JavaScript that provides a wide range of functions for tasks like string manipulation, array operations, and more.

**Special JS feature or syntax**

No special JavaScript features or syntax are mentioned in this benchmark. The focus is on comparing two approaches for merging objects.

**Alternatives**

Other alternatives for merging objects in JavaScript include:

* Using the `Object.assign()` method: This method merges all enumerable own properties of source objects into a new object.
* Using the `merge` function from other libraries like Underscore.js or Ramda
* Implementing your own custom merge function

For more information on these alternatives, you can explore other benchmark results on MeasureThat.net or consult JavaScript documentation.

Related benchmarks:

Lodash merge vs native spread and assign (version: 0)

Comparing performance of: Lodash merge vs Native

Created: 4 years ago by: Guest

Jump to the latest result

Lodash merge

Native

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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