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:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36

Browser/OS: Chrome 119 on Windows

View result in a separate tab

Test name	Executions per second
Ramda Drop - Fixed	625174.1 Ops/sec
Vanilla JS Slice - Fixed	637461.2 Ops/sec
Ramda Drop - Random Small	8123.0 Ops/sec
Vanilla JS Slice - Random Small	8167.4 Ops/sec
Ramda Drop - Random Large	0.4 Ops/sec
Vanilla JS Slice - Random Large	0.3 Ops/sec

Autogenerated LLM Summary (model llama3.1:latest, generated 2 months ago):

LLMs can make mistakes. Check important info.

Let's dive into the details of this benchmark.

**Benchmark Definition:**
The benchmark is comparing two approaches to manipulate arrays in JavaScript:

1. Using Ramda's `drop` function
2. Using vanilla JavaScript's `slice` method

The test cases are designed to measure the performance of these two approaches under different scenarios, including:

* Fixed-size arrays with a specific limit (`limiter`)
* Randomly generated small and large arrays

**Library:**
The benchmark uses Ramda, a popular functional programming library for JavaScript. Ramda provides a set of useful functions for working with data, including `drop`, which is used in this benchmark.

**JavaScript Features/Syntax:**

* The `map` method is used to transform each element of an array.
* The `concat` method is used to concatenate two arrays.
* The `Math.max` function is used to ensure that the `limiter` value does not exceed the length of the array when slicing.
* The `Array.from` method is used to convert a JavaScript iterable (e.g., an array-like object) into a proper array.

**Test Cases:**

The test cases cover the following scenarios:

1. **Ramda Drop - Fixed**: This test uses Ramda's `drop` function to remove elements from fixed-size arrays.
2. **Vanilla JS Slice - Fixed**: This test uses vanilla JavaScript's `slice` method to remove elements from fixed-size arrays.
3. **Ramda Drop - Random Small** and **Vanilla JS Slice - Random Small**: These tests use randomly generated small arrays (size 10) and apply the respective methods.
4. **Ramda Drop - Random Large** and **Vanilla JS Slice - Random Large**: These tests use randomly generated large arrays (size 300) and apply the respective methods.

**Performance Results:**
The latest benchmark results show that:

* Vanilla JavaScript's `slice` method is generally faster than Ramda's `drop` function, especially for larger array sizes.
* The performance difference between the two approaches increases as the array size grows.

**Other Considerations:**

* This benchmark only measures execution speed and does not consider other factors like memory usage or code complexity.
* The results might vary depending on the specific JavaScript engine and browser being used.

**Alternatives:**
If you need to manipulate arrays in JavaScript, you can consider using:

* Other functional programming libraries, such as Lodash or Immutable.js
* Vanilla JavaScript's built-in methods (e.g., `slice`, `splice`)
* Custom implementations using loops or recursion

Keep in mind that the best approach will depend on your specific use case and requirements.

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: 3 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>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.1:latest, generated 2 months ago):