Benchmark: lodash 21 merge vs object.assign vs spread

HTML Preparation code:


<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/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);
object.assign
var a = { a: 'oh', b: 'my' }; var b = { c: 'goddess' }; var c = Object.assign(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: 2 years ago)

User agent: Mozilla/5.0 (Windows NT 10.0; rv:103.0) Gecko/20100101 Firefox/103.0

Browser/OS: Firefox 103 on Windows

View result in a separate tab

Test name	Executions per second
lodash merge	3508036.2 Ops/sec
object.assign	11175928.0 Ops/sec
spread	5040421.5 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):

LLMs can make mistakes. Check important info.

Let's dive into the provided benchmark.

**What is being tested?**

The benchmark tests three approaches for merging two objects in JavaScript:

1. `_.merge` from the Lodash library
2. `Object.assign`
3. Spread syntax (`{ ...a, ...b }`)

These three approaches are compared to determine which one performs best in terms of execution time.

**Options comparison**

Here's a brief overview of each approach and their pros and cons:

1. **Lodash `_merge`**: This function merges two objects recursively. It's a powerful tool for merging complex objects, but it can also be slower due to its recursive nature.
	* Pros: flexible, supports nested objects
	* Cons: potentially slow, unnecessary complexity
2. **`Object.assign`**: This method creates a new object by copying all enumerable own properties from one or more source objects into a new object.
	* Pros: simple, fast
	* Cons: can be slower for large objects due to the overhead of creating a new object
3. **Spread syntax (`{ ...a, ...b }`)**: This syntax creates a new object by spreading the properties of two or more objects into a new object.
	* Pros: concise, efficient
	* Cons: limited support for nested objects, requires JavaScript 2015+ syntax

**Library and its purpose**

The Lodash library is a popular utility belt for JavaScript. It provides a wide range of functions for tasks such as:

* Array manipulation
* Object merging
* String formatting
* Event handling

In this benchmark, the `_merge` function from Lodash is used to merge two objects.

**Special JS feature or syntax**

The spread syntax (`{ ...a, ...b }`) requires JavaScript 2015+ syntax. It's a relatively new feature that allows for more concise object creation and merging.

**Other alternatives**

If these three approaches are not sufficient, other options could include:

* Using the `Object.create()` method to create a new object and then assigning properties from another object
* Using a library like Underscore.js or Ramda, which offer alternative merge functions

Keep in mind that these alternatives may have their own trade-offs in terms of performance, simplicity, and compatibility with older JavaScript versions.

**Benchmark preparation code**

The provided HTML preparation code includes the Lodash library, which is used for the `_.merge` function. The script preparation code is empty, indicating that no additional setup or initialization is required before running the benchmark.

I hope this explanation helps you understand what's being tested in this benchmark!

Related benchmarks:

lodash 21 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>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):