Benchmark: lodash merge vs lodash defaults vs spread

HTML Preparation code:

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

Tests:

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

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 3 years ago)

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

Browser/OS: Chrome 87 on Mac OS X 10.14.6

View result in a separate tab

Test name	Executions per second
lodash merge	2208834.2 Ops/sec
object.assign	3011845.5 Ops/sec
spread	1294026.4 Ops/sec

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

LLMs can make mistakes. Check important info.

The provided benchmark tests the performance of three different approaches to merge two objects in JavaScript: Lodash's `merge` function, `defaults`, and the spread operator (`...`).

**Lodash's `merge` function:**
This approach uses a utility library called Lodash. The `merge` function is used to merge two objects recursively. It returns a new object that contains all the properties from both input objects.

Pros:

* Easy to use and understand
* Handles nested objects and arrays

Cons:

* Requires an external dependency (Lodash)
* May not be suitable for very large datasets due to recursive function calls

**`defaults`:**
This approach uses the `_.defaults` method provided by Lodash. This method returns a new object that contains all the properties from both input objects, with any missing properties coming from the first object.

Pros:

* Similar syntax to `merge`, but with less overhead
* Still handles nested objects and arrays

Cons:

* Requires an external dependency (Lodash)
* May not be as efficient as the spread operator for very large datasets

**Spread Operator (`...`):**
This approach uses the spread operator, a new feature introduced in ECMAScript 2015. It allows you to create a new object by spreading the properties of an existing object.

Pros:

* No external dependencies required
* Fast and efficient, especially for large datasets
* Easy to understand and use

Cons:

* Limited support on older browsers or environments that don't support ES6+ features
* May not handle nested objects and arrays as elegantly as Lodash's `merge` function

In the context of this benchmark, the spread operator is likely the most efficient approach due to its fast execution time and lack of external dependencies. However, if you're working in an environment that doesn't support ES6+ features or prefer a more explicit way of merging objects, Lodash's `merge` function might be a better choice.

It's worth noting that these benchmarks are typically used for performance-critical code paths where every microsecond matters. In most other cases, the differences between these approaches will be negligible.

Related benchmarks:

lodash merge vs lodash defaults vs spread (version: 0)

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

Created: 4 years ago by: Guest

Jump to the latest result

lodash merge

object.assign

spread

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):