Benchmark: Ramda vs. Lodash vs. VanillaJS

Ramda vs. Lodash vs. VanillaJS (version: 0)

Compares performance on the same task using Lodash vs two styles of Ramda vs two styles of "native" Javascript. In all cases the task is pulling "counter" property from each item in an array, filtering out odd items, squaring them, then returning those squared values that have less than two digits.

Comparing performance of: Lodash vs Ramda without relying on currying or composition vs Ramda with currying and composition vs VanillaJS functional style vs VanillaJS procedural

Created: 4 years ago by: Guest

Jump to the latest result

HTML Preparation code:

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

Script Preparation code:

var data = [];
for (var i = 0; i < 10000; i++) {
     data.push({ counter: i });
}

function isOdd(num) {
  return num % 2 === 1;
}

function square(num) {
  return num * num;
}

function lessThanThreeDigits(num) {
  return num.toString().length < 3;
}

var expected = data.map(o => o.counter).filter(isOdd).map(square).filter(lessThanThreeDigits);

Tests:

Lodash
var result = _.chain(data) .map(d => _.get(d, 'counter')) .filter(isOdd) .map(square) .filter(lessThanThreeDigits) .value();
Ramda without relying on currying or composition
var result = R.filter(lessThanThreeDigits, R.map(square, R.filter(isOdd, R.pluck('counter', data))));
Ramda with currying and composition
var result = R.pipe( R.pluck('counter'), R.filter(isOdd), R.map(square), R.filter(lessThanThreeDigits) )(data);
VanillaJS functional style
var result = data.map(o => o.counter).filter(isOdd).map(square).filter(lessThanThreeDigits);
VanillaJS procedural
var result = new Array(); for (var i = 0; i < data.length; i++) { var c = data[i].counter; if (isOdd(c)) { var r = square(c); if (lessThanThreeDigits(r)) { result.push(r); } } }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash
Ramda without relying on currying or composition
Ramda with currying and composition
VanillaJS functional style
VanillaJS procedural

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 27 days ago):

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what's being tested.

**Benchmark Description**

The benchmark compares the performance of three JavaScript libraries: Ramda, Lodash, and VanillaJS (native JavaScript). The test case is designed to measure the execution time of an array processing pipeline that involves:

1. Extracting a specific property (`counter`) from each object in the array.
2. Filtering out odd numbers using the `isOdd` function.
3. Squaring the remaining numbers using the `square` function.
4. Filtering the squared values to only include those with less than 2 digits.

**Options Compared**

The benchmark compares four different approaches:

1. **VanillaJS functional style**: This approach uses arrow functions and the `map`, `filter`, and `reduce` methods to process the array in a functional programming style.
2. **VanillaJS procedural**: This approach uses traditional loops (for loops) to iterate through the array and perform the operations sequentially.
3. **Ramda without relying on currying or composition**: Ramda is a functional programming library that provides a set of higher-order functions for working with data. In this case, we're comparing its performance to VanillaJS using only the `filter`, `map`, and `reduce` methods, without leveraging its currying or composition features.
4. **Ramda with currying and composition**: This approach takes full advantage of Ramda's functional programming capabilities, including currying (transforming functions into higher-order functions) and composition (building new functions from existing ones).

**Pros and Cons**

Here are some general pros and cons of each approach:

* **VanillaJS functional style**:
	+ Pros: Easy to understand and implement, leverages modern JavaScript features.
	+ Cons: May not be as performant due to the overhead of method calls.
* **VanillaJS procedural**:
	+ Pros: Can be more straightforward for simple operations, avoids method call overhead.
	+ Cons: May lead to performance issues with complex pipelines or large datasets.
* **Ramda without currying/composition**: Using only Ramda's basic filtering and mapping functions can result in slower performance compared to leveraging its higher-order functions.
* **Ramda with currying and composition**: Offers the most performant approach by taking advantage of Ramda's optimized implementation and functional programming principles.

**Library Usage**

In this benchmark, we're using:

* Ramda: A functional programming library for JavaScript. The `filter`, `map`, and `reduce` methods are used to process the array.
* Lodash: Another popular JavaScript utility library that provides a set of higher-order functions for working with data. In this case, only the `chain` method is used.

**Special JS Features**

This benchmark doesn't explicitly use any special JavaScript features or syntax. However, it does leverage modern JavaScript concepts like:

* Arrow functions (`=>`)
* Method calls (`map`, `filter`, etc.)
* Higher-order functions (functions that take other functions as arguments)

Overall, this benchmark provides a solid comparison of the performance differences between using Ramda, Lodash, and VanillaJS for array processing pipelines.

Latest run results:

Run details: (Test run date: 15 days ago)

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

Browser/OS: Chrome 129 on Windows

View result in a separate tab

Test name	Executions per second
Lodash	216.6 Ops/sec
Ramda without relying on currying or composition	206.1 Ops/sec
Ramda with currying and composition	203.7 Ops/sec
VanillaJS functional style	2159.0 Ops/sec
VanillaJS procedural	399.1 Ops/sec

Related benchmarks:

Ramda vs. Lodash vs. VanillaJS (version: 0)

Compares performance on the same task using Lodash vs two styles of Ramda vs two styles of "native" Javascript. In all cases the task is pulling "counter" property from each item in an array, filtering out odd items, squaring them, then returning those squared values that have less than two digits.

Comparing performance of: Lodash vs Ramda without relying on currying or composition vs Ramda with currying and composition vs VanillaJS functional style vs VanillaJS procedural

Created: 4 years ago by: Guest

Jump to the latest result

Lodash

Ramda without relying on currying or composition

Ramda with currying and composition

VanillaJS functional style

VanillaJS procedural

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 27 days ago):