Benchmark: lodash assign vs object.assign vs spread

HTML Preparation code:

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

Tests:

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

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash assign with inplace object creation
object.assign
spread
lodash assign with object creation before

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested.

**Main Test Case:** The main test case is comparing three different approaches to merge two objects:

1. `lodash assign` (using the `_` object from Lodash library)
2. `object.assign`
3. Spread syntax (`...`)

**Library and Purpose:**

* `_.assign` is a function from the Lodash library, which provides utility functions for functional programming in JavaScript. In this context, it's used to merge two objects.
* `Object.assign` is a built-in method of the JavaScript `Object` prototype, which merges one or more source objects into a target object.

**Spread Syntax (`...`):**

The spread syntax is a feature introduced in ECMAScript 2015 (ES6) that allows you to expand an array or object into individual elements or properties. When used with the assignment operator (`=`), it creates a new object by merging the existing object's properties with the ones from the source.

**Options being compared:**

The three options are being compared in terms of performance:

* `_.assign` vs `object.assign`: Both methods merge objects, but they might have different implementations or optimizations.
* `_.assign` vs Spread syntax (`...`): This comparison tests how efficient it is to use the spread syntax for object merging.

**Pros and Cons:**

* **_.assign**: Pros:
	+ Widely supported in older browsers due to its inclusion in Lodash.
	+ Might be optimized for specific use cases or environments.
Cons:
	+ Requires an additional library (Lodash) to be loaded.
	+ May have different implementation details compared to `object.assign`.
* **object.assign**: Pros:
	+ Built-in method, so no additional library is required.
	+ Widely supported in modern browsers and Node.js.
Cons:
	+ Might not be optimized for specific use cases or environments.
	+ Can lead to unexpected behavior if not used correctly (e.g., using it with arrays instead of objects).
* **Spread syntax (`...`)**: Pros:
	+ Native JavaScript feature, so no additional library is required.
	+ Simple and concise syntax.
Cons:
	+ Support for spread syntax is only available in ECMAScript 2015 (ES6) and later versions.

**Other Considerations:**

* The test case uses a relatively simple object structure (`{ a: 'oh', b: 'my' }`), which might not be representative of real-world scenarios.
* No error handling or edge cases are tested, so the results should be considered in the context of expected behavior for these specific use cases.

**Alternatives:**

* If you're looking for alternatives to `_.assign`, you can consider using `Object.create()` or a simple object merge function with loops (e.g., `for (const key in obj) { target[key] = source[key]; }`).
* For more complex merging scenarios, you might need to use a dedicated library like Lodash or Ramda.

Latest run results:

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

User agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:74.0) Gecko/20100101 Firefox/74.0

Browser/OS: Firefox 74 on Ubuntu

View result in a separate tab

Test name	Executions per second
lodash assign with inplace object creation	3674652.0 Ops/sec
object.assign	4366035.5 Ops/sec
spread	2101695.8 Ops/sec
lodash assign with object creation before	3814207.8 Ops/sec

Related benchmarks:

lodash assign vs object.assign vs spread (version: 0)

Comparing performance of: lodash assign with inplace object creation vs object.assign vs spread vs lodash assign with object creation before

Created: 4 years ago by: Guest

Jump to the latest result

lodash assign with inplace object creation

object.assign

spread

lodash assign with object creation before

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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