Toggle navigation
MeasureThat
.net
Create a benchmark
Tools
Feedback
FAQ
Register
Log In
spread vs assign vs _.merge
(version: 0)
Comparing performance of:
lodash merge vs object.assign vs spread
Created:
7 years ago
by:
Registered User
Go to the latest result
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 = 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>
Run tests (3)
Previous results
Fork
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 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36
Browser/OS:
Chrome 120 on Mac OS X 10.15.7
View result in a separate tab
Embed
Embed Benchmark Result
<iframe src="https://measurethat.net/Embed?id=506424" width="100%" height="500px"></iframe>
spread
41.4M/s
object.assign
9.6M/s
lodash merge
8.1M/s
View exact numbers
Test name
Executions per second
✓
spread
41,426,172 Ops/sec
object.assign
9,591,334 Ops/sec
lodash merge
8,067,011 Ops/sec
Autogenerated LLM Summary
(model
llama3.2:3b
, generated one year ago):
Let's break down the provided benchmark and explain what's being tested, along with the pros and cons of each approach. **Benchmark Overview** The benchmark measures the performance of three different ways to merge two objects in JavaScript: `_.merge` (from the Lodash library), `Object.assign()`, and the spread operator (`...`). **Test Cases** Each test case consists of a brief description of how the object merging is performed, followed by the name of the benchmark. The tests are: 1. `lodash merge`: Merges two objects using Lodash's `merge()` function. 2. `object.assign()`: Merges two objects using the `Object.assign()` method. 3. `spread`: Merges two objects using the spread operator (`...`). **Library: Lodash** Lodash is a popular JavaScript utility library that provides a wide range of functions for common tasks, such as string manipulation, array manipulation, and object manipulation. The `merge()` function in Lodash takes two objects as arguments and returns a new object containing all properties from both input objects. **Pros and Cons of Each Approach** 1. **_.merge (Lodash)**: * Pros: Robust implementation with built-in support for many edge cases, such as arrays and null values. * Cons: Add an extra dependency on the Lodash library, which may not be desirable in all situations. 2. **Object.assign()**: * Pros: Native JavaScript method that doesn't require any external libraries, making it a simple choice. * Cons: Can lead to issues with nested arrays or objects, as well as potential security concerns due to its use of the `eval()` function for deep merging (although this is not enabled by default). 3. **Spread Operator (`...`)**: * Pros: Simple and intuitive way to merge objects, with no additional dependencies. * Cons: Not supported in older browsers or environments that don't support ES6+ syntax. **Other Considerations** When choosing an object merging approach, consider the following factors: * Performance: `_.merge()` may be faster due to its optimized implementation, while `Object.assign()` can lead to slower performance due to its use of `eval()`. The spread operator is generally fast but may not be as performant in all cases. * Complexity: If you need to merge objects with nested arrays or complex structures, `_.merge()` may be a better choice. Otherwise, the spread operator or `Object.assign()` might suffice. **Alternatives** If you're interested in exploring other object merging approaches, consider: 1. **JSON Merge Patch**: A library that provides a more efficient and flexible way to merge objects. 2. **Deep Copy**: Use a library like Lodash's `cloneDeep()` or the `lodash.extend` method with the `deep: true` option to create a deep copy of an object. 3. **Manual Merging**: Implement your own manual merging logic using nested loops and conditional statements. These alternatives may offer better performance, flexibility, or simplicity depending on your specific use case.
Related benchmarks
lodash.assign vs object.assign vs spread
lodash assign vs object.assign vs spread operator - variable and constant
Comments
Confirm delete:
Do you really want to delete benchmark?