Benchmark: lodash clone vs ramda clone vs spread

HTML Preparation code:

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

Script Preparation code:

var arr = new Array(1000000).fill({a:100, b:20000});

Tests:

spread
[...arr]
lodash clone
_.clone(arr)
ramda clone
R.clone(arr)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
spread
lodash clone
ramda clone

Fastest: N/A

Slowest: N/A

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/136.0.0.0 Safari/537.36

Browser/OS: Chrome 136 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
spread	5330.6 Ops/sec
lodash clone	689.0 Ops/sec
ramda clone	16.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 benchmark and its test cases.

**Benchmark Overview**

The benchmark measures the performance of three different ways to create a shallow copy of an array using JavaScript:

1. **Spread operator**: The `[...arr]` syntax creates a new array by spreading the elements of `arr`.
2. **Lodash cloning function**: The `_.clone(arr)` function from the Lodash library creates a deep copy of the array.
3. **Ramda cloning function**: The `R.clone(arr)` function from the Ramda library creates a shallow copy of the array.

**Test Case Comparison**

The three test cases are compared to determine which approach is fastest and most efficient.

* **Spread operator**: Creates a new array by spreading the elements of `arr`. This method has a time complexity of O(n), where n is the length of the original array.
* **Lodash cloning function**: Creates a deep copy of the array using Lodash's `clone` function. This method has a time complexity of O(n) for shallow copies and O(n^2) for deep copies, depending on the implementation.
* **Ramda cloning function**: Creates a shallow copy of the array using Ramda's `clone` function. This method has a time complexity of O(n), but it may be slower than the spread operator due to potential overhead from the library.

**Pros and Cons**

Here are some pros and cons of each approach:

* **Spread operator**:
	+ Pros: Fast, efficient, and widely supported.
	+ Cons: May not work well with complex data structures or large arrays.
* **Lodash cloning function**:
	+ Pros: Provides a consistent and reliable way to create copies of arrays.
	+ Cons: May be slower than the spread operator due to library overhead.
	+ Cons: May be overkill for simple use cases, requiring more dependencies.
* **Ramda cloning function**:
	+ Pros: Provides a lightweight alternative to Lodash's clone function.
	+ Cons: May not work well with complex data structures or large arrays.

**Library and Syntax Explanation**

* **Lodash library**: A popular utility library that provides a wide range of functions for tasks like array manipulation, string manipulation, and more. The `_.clone` function is part of the Lodash library.
* **Ramda library**: A functional programming library that provides a concise way to work with arrays, objects, and other data structures. The `R.clone` function is part of the Ramda library.

**Special JavaScript Feature**

The benchmark uses the spread operator (`[...arr]`) which is a relatively recent feature introduced in ECMAScript 2015 (ES6). This syntax allows for creating new arrays by spreading the elements of an existing array. The benchmark also uses the `_.clone` and `R.clone` functions from Lodash and Ramda, respectively.

**Other Alternatives**

If you need to create a shallow copy of an array without using the spread operator or a library like Lodash/Ramda, you can use the following approaches:

* **Using Array.prototype.slice()**: `new Array(arr.length).fill().map((_, i) => arr[i])`
* **Using Array.prototype.reduce()**: `[...arr.reduce((acc, curr) => [...acc, curr], [])]`

These alternatives have similar time complexities to the spread operator and may be suitable for simple use cases. However, they may not be as efficient or convenient to use in more complex scenarios.

Keep in mind that these alternatives require more code and may not provide the same level of readability and concision as the spread operator or library functions like `_.clone`/`R.clone`.

Related benchmarks:

lodash clone vs ramda clone vs spread (version: 0)

Comparing performance of: spread vs lodash clone vs ramda clone

Created: 5 years ago by: Guest

Jump to the latest result

spread

lodash clone

ramda clone

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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