Benchmark: ramda clone vs spread on obj

HTML Preparation code:

<script src="//cdn.jsdelivr.net/npm/ramda@0.25.0/dist/ramda.min.js"></script>

Script Preparation code:

var obj = { a: 123, b: 345, c: 'abc' }

Tests:

spread
var obj2 = { ...obj, b: 999 };
ramda clone
var obj2 = R.clone(obj); obj2.b = 999;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
spread
ramda clone

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll explain the benchmark in detail.

**Benchmark Overview**

The provided JSON represents a JavaScript microbenchmark that tests two approaches to creating an object with similar properties: using the spread operator (`...`) and cloning an existing object using a library called Ramda.

**Script Preparation Code**

```javascript
var obj = { a: 123, b: 345, c: 'abc' };
```

This code defines an initial object `obj` with three properties: `a`, `b`, and `c`.

**Html Preparation Code**

The HTML code includes a script tag that loads the Ramda library from a CDN:

```html
<script src="https://cdn.jsdelivr.net/npm/ramda@0.25.0/dist/ramda.min.js"></script>
```

This library provides a way to clone and manipulate JavaScript objects.

**Individual Test Cases**

There are two test cases:

1. **"spread"`**: This test case creates an object `obj2` by spreading the properties of `obj` into a new object, and then updates the value of property `b` to 999.
```javascript
var obj2 = { ...obj, b: 999 };
```
This approach creates a shallow copy of the original object using the spread operator.

2. **"ramda clone"`**: This test case uses Ramda's `R.clone()` function to create a cloned version of the `obj` object and then updates the value of property `b` to 999.
```javascript
var obj2 = R.clone(obj);
obj2.b = 999;
```
This approach creates a deep copy of the original object by using Ramda's cloning mechanism.

**Benchmark Results**

The benchmark results show the execution counts per second for each test case across different browsers and devices:

| Test Name | Browser | Device Platform | Operating System | Executions Per Second |
| --- | --- | --- | --- | --- |
| spread | Chrome 114 | Desktop | Mac OS X 10.15.7 | 22126888.0 |
| ramda clone | Chrome 114 | Desktop | Mac OS X 10.15.7 | 4149400.75 |

**Pros and Cons of Each Approach**

1. **Spread Operator (`...`)**
	* Pros:
		+ Simple and concise syntax
		+ Creates a shallow copy of the original object
		+ Fast execution time
	* Cons:
		+ Does not create a deep copy, which can lead to unexpected behavior when dealing with nested objects
		+ Can be slow for large objects due to its shallow copying nature
2. **Ramda Clone (`R.clone()`)**
	* Pros:
		+ Creates a deep copy of the original object
		+ Ensures predictable behavior when dealing with nested objects
	* Cons:
		+ More verbose syntax compared to the spread operator
		+ Can be slower execution time due to its cloning mechanism

**Other Alternatives**

For creating deep copies of objects, other alternatives include:

1. **JSON.parse(JSON.stringify(obj))**: This method creates a deep copy by serializing the object to JSON and then parsing it back.
2. **lodash.cloneDeep()**: This function provides a safe way to clone deep JavaScript objects using Lodash's `cloneDeep` utility.

These alternatives can be used as an alternative to Ramda's `R.clone()` function, but may have different performance characteristics or syntax requirements.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36

Browser/OS: Chrome 114 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
spread	22126888.0 Ops/sec
ramda clone	4149400.8 Ops/sec

Related benchmarks:

ramda clone vs spread on obj (version: 0)

Comparing performance of: spread vs ramda clone

Created: 4 years ago by: Guest

Jump to the latest result

spread

ramda clone

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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