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

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

Autogenerated LLM Summary (model llama3.2:3b, generated one year 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.

Related benchmarks:

ramda clone vs spread on obj (version: 0)

Comparing performance of: spread vs ramda clone

Created: 5 years ago by: Guest

Jump to the latest result

spread

ramda clone

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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