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>

AخA
 
<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);

​x
 
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();

 
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))));
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);
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);
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);
    }
  }
}

 
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

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

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

Latest run results:

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

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

Browser/OS: Chrome 132 on Windows

View result in a separate tab

Test name	Executions per second
Lodash	1773.3 Ops/sec
Ramda without relying on currying or composition	1002.1 Ops/sec
Ramda with currying and composition	980.2 Ops/sec
VanillaJS functional style	2693.2 Ops/sec
VanillaJS procedural	6727.4 Ops/sec

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

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:

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

Options Compared

The benchmark compares four different approaches:

VanillaJS functional style: This approach uses arrow functions and the map, filter, and reduce methods to process the array in a functional programming style.
VanillaJS procedural: This approach uses traditional loops (for loops) to iterate through the array and perform the operations sequentially.
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.
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.

LLMs can make mistakes. Check important info.

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

**Benchmark Description**

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.

Related benchmarks: