Benchmark: Ramda Drop vs Vanilla JS Slice

HTML Preparation code:

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

Script Preparation code:

var X = 'x'
var newData = [X, X, X, X, X, X]
var limiter = 4
var data = [
    [1, 2, 3, 4, 5, 6],
    [3, 4, 5, 6, 7, 8],
    [1, 2, 3, 4, 5, 6],
    [3, 4, 5, 6, 7, 8],
    [1, 2, 3, 4, 5, 6],
    [3, 4, 5, 6, 7, 8]
]

var newDataGen = (num) => Array.from(Array(num)).map(() => Math.floor(Math.random() * 10))

var dataGen = (num, num2) => Array.from(Array(num)).map(() => Array.from(Array(num2)).map(() => Math.floor(Math.random() * 10)))

Tests:

Ramda Drop - Fixed
newData.map((dataPoint, idx)=>{ return R.drop(limiter, data[idx]).concat(dataPoint) })
Vanilla JS Slice - Fixed
newData.map((dataPoint, idx)=>{ return data[idx].slice(Math.max(0,limiter), Infinity).concat(dataPoint) })
Ramda Drop - Random Small
newDataGen(10).map((dataPoint, idx)=>{ return R.drop(limiter, dataGen(10,10)[idx]).concat(dataPoint) })
Vanilla JS Slice - Random Small
newDataGen(10).map((dataPoint, idx)=>{ return dataGen(10,10)[idx].slice(Math.max(0,limiter), Infinity).concat(dataPoint) })
Ramda Drop - Random Large
newDataGen(300).map((dataPoint, idx)=>{ return R.drop(limiter, dataGen(300,300)[idx]).concat(dataPoint) })
Vanilla JS Slice - Random Large
newDataGen(300).map((dataPoint, idx)=>{ return dataGen(300,300)[idx].slice(Math.max(0,limiter), Infinity).concat(dataPoint) })

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Ramda Drop - Fixed
Vanilla JS Slice - Fixed
Ramda Drop - Random Small
Vanilla JS Slice - Random Small
Ramda Drop - Random Large
Vanilla JS Slice - Random Large

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 gemma2:9b, generated one year ago):

LLMs can make mistakes. Check important info.

This benchmark compares the performance of Ramda's `drop` function against vanilla JavaScript's `slice` method for removing elements from an array.

**Options Compared:**

* **Ramda Drop (`R.drop`)**: This is a functional programming approach using the Ramda library. 
    * It takes two arguments: the number of elements to drop and the array. 
    * Returns a new array with the specified elements removed from the beginning.
* **Vanilla JS Slice (`slice()`)**: This is a built-in JavaScript method.
    * It takes two arguments: the starting index (inclusive) and the ending index (exclusive).
    * Returns a new array containing the elements from the start to end index.

**Pros/Cons:**

| Approach            | Pros                                        | Cons                                         |
|---------------------|---------------------------------------------|-----------------------------------------------|
| Ramda `drop`       |  - Concise and functional style              | - Requires an external library (Ramda)      |
| Vanilla JS `slice` | - Built-in, no extra dependencies            | - Can be more verbose than Ramda `drop`     |

**Benchmark Details:**

The benchmark tests the performance of both approaches in different scenarios:

* **Fixed**: Removing a fixed number of elements from the beginning of an array.
* **Random Small**: Removing a variable number of elements (smaller size) from the beginning.
* **Random Large**: Removing a variable number of elements (larger size) from the beginning.

**Results:**

The results show that vanilla JavaScript's `slice` performs better for smaller datasets and fixed element removals. However, Ramda's `drop` appears to struggle significantly when dealing with larger datasets.

**Alternatives:**  
 There are other methods in JavaScript for removing array elements, such as `splice`. These might offer different performance characteristics depending on the use case.

**Conclusion:**

The best approach depends on your specific needs and priorities. If you value conciseness and functional programming style, Ramda's `drop` might be suitable. However, if raw performance is critical and you are dealing with large datasets, vanilla JavaScript's `slice` might be more efficient.

Related benchmarks:

Ramda Drop vs Vanilla JS Slice (version: 4)

Comparing performance of: Ramda Drop - Fixed vs Vanilla JS Slice - Fixed vs Ramda Drop - Random Small vs Vanilla JS Slice - Random Small vs Ramda Drop - Random Large vs Vanilla JS Slice - Random Large

Created: 5 years ago by: Registered User

Jump to the latest result

Ramda Drop - Fixed

Vanilla JS Slice - Fixed

Ramda Drop - Random Small

Vanilla JS Slice - Random Small

Ramda Drop - Random Large

Vanilla JS Slice - Random Large

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

Autogenerated LLM Summary (model gemma2:9b, generated one year ago):