Benchmark: mergeWith vs object.assign vs spread12

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', d: 'ss' }; var b = { c: 'goddess', d: 's2s' }; var c = _.mergeWith(a, b); console.log('mergeWith', c)
object.assign
var a = { a: 'oh', b: 'my', d: 'ss' }; var b = { c: 'goddess', d: 's2s' }; var c = Object.assign(a, b); console.log('assign', c)
spread
var a = { a: 'oh', b: 'my', d: 'ss' }; var b = { c: 'goddess', d: 's2s' }; var c = { ...a, ...b }; console.log('spread', c)

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

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

The provided JSON represents a benchmark test case that compares three approaches for merging two objects: `lodash.mergeWith`, `object.assign`, and spread operator (`{ ...a, ...b }`).

**Options being compared:**

1. **_lodash.mergeWith**: A utility function from the Lodash library (specifically, v4.17.5) that merges two objects using a custom merge strategy.
2. **object.assign**: A built-in JavaScript method that merges two or more source objects into a new object.
3. **Spread operator (`{ ...a, ...b }`)**: A syntax sugar introduced in ECMAScript 2018 that creates a new object with the properties of `a` and `b`.

**Pros and Cons of each approach:**

1. **_lodash.mergeWith_**
	* Pros:
		+ Customizable merge strategy through options.
		+ Can handle complex data structures (e.g., nested objects).
	* Cons:
		+ Requires the Lodash library, which may add overhead.
		+ May have slower performance due to the extra function call.
2. **object.assign**
	* Pros:
		+ Built-in and optimized for performance.
		+ Easy to use and understand.
	* Cons:
		+ Limited control over merge strategy (e.g., only supports shallow merges).
		+ May not handle complex data structures as efficiently.
3. **Spread operator (`{ ...a, ...b }`**)
	* Pros:
		+ Simple and concise syntax.
		+ Fast and efficient for simple cases.
	* Cons:
		+ Limited control over merge strategy (only supports shallow merges).
		+ May not work well with complex data structures or deeply nested objects.

**Other considerations:**

* The use of Lodash's `mergeWith` function provides a more flexible approach, but at the cost of added overhead and complexity.
* `object.assign` is a good choice for simple cases, but may struggle with more complex data structures.
* The spread operator is a convenient option for shallow merges, but its limitations should be considered.

**Library and syntax used:**

The benchmark uses Lodash's `mergeWith` function, which is available as a utility library. No special JavaScript features or syntax are required to run the benchmark.

**Benchmark preparation code:**

The provided HTML includes a script tag that loads the Lodash library (v4.17.5). The script preparation code is empty, suggesting that the focus is on comparing the three merge approaches rather than preparing any additional data.

Latest run results:

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

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

Browser/OS: Chrome 103 on Windows

View result in a separate tab

Test name	Executions per second
lodash merge	192853.8 Ops/sec
object.assign	23776.4 Ops/sec
spread	22996.9 Ops/sec

Related benchmarks:

mergeWith vs object.assign vs spread12 (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 26 days ago):