Benchmark: ramda includes vs array includes

HTML Preparation code:

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

Script Preparation code:

var arr = ['I','a','m','a','r','r','a','y','t','o','c','h','e','c','k'];

Tests:

native
var result = arr.includes('y')
ramda
var result = R.includes('y', arr);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
native
ramda

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 3 years ago)

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

Browser/OS: Chrome 100 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
native	23415200.0 Ops/sec
ramda	7023228.5 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):

LLMs can make mistakes. Check important info.

Let's dive into the explanation.

The provided benchmark measures the performance difference between using native JavaScript `includes()` method and Ramda's `R.includes()` function to check if an element exists in an array.

**Native JavaScript includes() method**

The native JavaScript `includes()` method is a built-in function that checks if a specified value (in this case, 'y') exists in the given array (`arr`). This method returns `true` if the value is found, and `false` otherwise. The pros of using native `includes()` are:

1. **Performance**: Native code execution is generally faster than executing external library functions.
2. **Low overhead**: The native implementation has minimal overhead compared to other alternatives.

However, there are some cons to consider:

1. **Browser compatibility**: While the native implementation might be supported by most modern browsers, older versions or browsers with limited JavaScript capabilities might not have this method available.
2. **Limited functionality**: Native `includes()` only checks for exact value matches; it doesn't provide additional features like finding the index of the element.

**Ramda's R.includes() function**

The Ramda library provides a higher-order function called `R.includes()` that takes two arguments: the value to search for (`'y'`) and the array to search in (`arr`). This function returns `true` if the value is found, and `false` otherwise. The pros of using Ramda's `R.includes()` are:

1. **Consistency**: Ramda provides a consistent implementation across different browsers and environments.
2. **Additional features**: Ramda's `R.includes()` can be used with other functions to create more complex queries.

However, there are some cons to consider:

1. **Overhead**: Since Ramda is an external library, its execution incurs additional overhead compared to native code execution.
2. **Dependency on the library**: The test relies on Ramda being available and correctly configured in the browser.

**Other alternatives**

In addition to native `includes()` and Ramda's `R.includes()`, other alternatives could be considered:

1. **Array.prototype.some() or Array.prototype.every()**: While not exact matches, these methods can be used to achieve similar results with more flexibility.
2. **Using a library like Lodash's includes() function**: Like Ramda, Lodash provides a version of `includes()` that can be used in place of the native implementation.

In summary, when choosing between native JavaScript `includes()` and Ramda's `R.includes()`, consider factors such as performance, browser compatibility, and additional features required.

Related benchmarks:

ramda includes vs array includes (version: 0)

Comparing performance of: native vs ramda

Created: 3 years ago by: Guest

Jump to the latest result

native

ramda

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):