Benchmark: lodash merge, lodash assign, Object.assign, es6 spread

HTML Preparation code:

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

Tests:

lodash assign (shallow copy)
var a = { a: 'This is not Vietnam, this is bowling!', b: 'There are rules!' }; var b = { c: "Dude." }; var c = _.assign(a, b);
Object.Assign (in-place modify)
var a = { a: 'This is not Vietnam, this is bowling!', b: 'There are rules!' }; var b = { c: "Dude." }; var c = Object.assign(a, b);
lodash merge (deep copy)
var a = { a: 'This is not Vietnam, this is bowling!', b: 'There are rules!' }; var b = { c: "Dude." }; var c = _.merge(a, b);
ES6 spread (new object)
var a = { a: 'This is not Vietnam, this is bowling!', b: 'There are rules!' }; var b = { c: "Dude." }; var c = { ...a, ...b };

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash assign (shallow copy)
Object.Assign (in-place modify)
lodash merge (deep copy)
ES6 spread (new object)

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 112 on Windows

View result in a separate tab

Test name	Executions per second
lodash assign (shallow copy)	3332342.2 Ops/sec
Object.Assign (in-place modify)	4206730.5 Ops/sec
lodash merge (deep copy)	1812334.9 Ops/sec
ES6 spread (new object)	1352337.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

**Benchmark Overview**

The provided JSON represents a benchmark test case that compares four approaches to merge or assign objects in JavaScript:

1. `lodash.assign` (shallow copy)
2. `Object.assign` (in-place modify)
3. `_.merge` (deep copy) from the Lodash library
4. ES6 spread operator (`{ ...a, ...b }`) for creating a new object

**Options Comparison**

The four options are compared in terms of their performance, which is measured by the number of executions per second.

* **Lodash `assign`:** Shallow copies an object, meaning it only copies the top-level properties without recursively copying nested objects. This approach can be faster for simple objects but may lose data if there are deeply nested objects.
* **`Object.assign`:** Modifies the original object in-place, which means it modifies the existing object and returns `undefined`. This approach can be slower because it requires modifying the original object, and any changes made to the original object will not be preserved in subsequent iterations.
* **Lodash `merge`:** Deeply copies an object, meaning it recursively copies all properties including nested objects. This approach can preserve data but may be slower due to the recursive copying process.
* **ES6 spread operator:** Creates a new object with the values from two or more existing objects. This approach is fast and efficient because it only requires creating a new object without modifying any existing ones.

**Pros and Cons**

Here's a brief summary of each option:

* `Lodash `assign`:**
	+ Pros: Fast for simple objects, easy to use.
	+ Cons: May lose data with deeply nested objects.
* `Object.assign`:**
	+ Pros: In-place modify, which can be useful in some scenarios.
	+ Cons: Slower due to modifying the original object.
* Lodash `merge`:
	+ Pros: Preserves data even with deeply nested objects.
	+ Cons: May be slower due to recursive copying process.
* ES6 spread operator:
	+ Pros: Fast, efficient, and easy to use.
	+ Cons: None notable.

**Library and Special JS Features**

In this benchmark, the Lodash library is used for the `assign` and `merge` functions. The `Object.assign` method is a built-in JavaScript function that performs in-place modification.

There are no special JS features or syntax mentioned in the provided benchmark. However, it's worth noting that some modern browsers support additional features like ES6 spread operator, which is used in the benchmark.

**Alternatives**

If you're looking for alternatives to these options, consider:

* For shallow copying: `Object.assign` (with a twist, e.g., using `Object.create(null)` to create a new object without inheritance) or `JSON.parse(JSON.stringify(obj))`
* For in-place modification: `Object.keys().forEach()` or `Array.prototype.forEach.call(Object.keys(obj), function(key) { ... })`
* For deep copying: Lodash `cloneDeep` (if you're not using Lodash's `merge` function) or a custom implementation
* For ES6 spread operator: no alternative, as it's a standard feature in modern browsers and Node.js.

Keep in mind that the choice of approach depends on your specific use case and performance requirements.

Related benchmarks:

lodash merge, lodash assign, Object.assign, es6 spread (version: 0)

Comparing performance of: lodash assign (shallow copy) vs Object.Assign (in-place modify) vs lodash merge (deep copy) vs ES6 spread (new object)

Created: one year ago by: Guest

Jump to the latest result

lodash assign (shallow copy)

Object.Assign (in-place modify)

lodash merge (deep copy)

ES6 spread (new object)

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