Benchmark: ramda merge.all vs object.assign vs spread

HTML Preparation code:

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

Tests:

Ramda merge
var a = { a: 'oh', b: 'my' }; var b = { c: 'goddess' }; var c = { b: 'hello' }; var d = R.mergeAll(a, b, c);
object.assign
var a = { a: 'oh', b: 'my' }; var b = { c: 'goddess' }; var c = { b: 'hello' }; var d = Object.assign(a, b, c);
spread
var a = { a: 'oh', b: 'my' }; var b = { c: 'goddess' }; var c = { b: 'hello' }; var c = { ...a, ...b, ...c };

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Ramda 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; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 Edg/120.0.0.0

Browser/OS: Chrome 120 on Windows

View result in a separate tab

Test name	Executions per second
Ramda merge	4194096.2 Ops/sec
object.assign	11431604.0 Ops/sec
spread	29886870.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and its test cases.

**Benchmark Overview**

The benchmark compares three approaches for merging objects in JavaScript: `R.mergeAll` from the Ramda library, `Object.assign`, and the spread operator (`...`). The goal is to determine which approach performs better in terms of execution speed.

**Options Compared**

* **Ramda mergeAll**: A functional programming approach that merges all input objects into a single object. It uses the `mergeAll` function from the Ramda library.
* **Object.assign**: A built-in JavaScript method that merges all properties from multiple sources (objects) into a single destination object.
* **Spread Operator (`...`)**: A syntax feature introduced in ECMAScript 2015, which allows for spreading the properties of one or more objects into another object.

**Pros and Cons**

* **Ramda mergeAll**:
	+ Pros:
		- Highly optimized for performance
		- Supports merging multiple objects with ease
		- Part of a functional programming framework (Ramda)
	+ Cons:
		- Requires the Ramda library, which may add overhead
		- May not be familiar to developers without experience with Ramda or functional programming
* **Object.assign**:
	+ Pros:
		- Built-in method, no additional libraries required
		- Simple and straightforward syntax
	+ Cons:
		- Can be slower than `R.mergeAll` due to the overhead of creating a new object and copying properties
		- Does not support merging multiple objects with different keys (e.g., using `{ a: 'oh', b: 'my' }` as one object, but `{ c: 'goddess' }` as another)
* **Spread Operator (`...`)**:
	+ Pros:
		- Simple and intuitive syntax
		- Fast performance due to the use of property accessors (e.g., `obj.a` instead of `obj['a']`)
	+ Cons:
		- Limited support for merging objects with different keys (e.g., cannot directly merge `{ a: 'oh', b: 'my' }` and `{ c: 'goddess' }`)
		- Only available in ECMAScript 2015 and later versions

**Library/Feature Descriptions**

* **Ramda**: A functional programming library for JavaScript that provides various utility functions, including `mergeAll`.
* **Spread Operator (`...`)**: A syntax feature introduced in ECMAScript 2015, which allows for spreading the properties of one or more objects into another object.

**Other Considerations**

When choosing between these approaches, consider the following:

* **Performance**: If speed is crucial, `R.mergeAll` may be a better choice. However, this requires familiarity with Ramda and functional programming concepts.
* **Readability**: The spread operator provides an easy-to-understand syntax for merging objects.
* **Platform Support**: Not all browsers or environments support the spread operator (e.g., older versions of Internet Explorer).

**Alternatives**

If you're not using Ramda, you can also use other libraries like Lodash (`_.mergeAll`) or implement your own object merger function.

Keep in mind that this benchmark is specific to merging objects and does not account for other factors that might affect performance, such as the size of the input objects or the complexity of the merge logic.

Related benchmarks:

ramda merge.all vs object.assign vs spread (version: 0)

Comparing performance of: Ramda merge vs object.assign vs spread

Created: 5 years ago by: Guest

Jump to the latest result

Ramda merge

object.assign

spread

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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