Benchmark: Ramda (/w transducer no pluck) vs. Lodash

Ramda (/w transducer no pluck) vs. Lodash (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: JS native vs Ramda with transducer vs Ramda with currying and composition vs Ramda without relying on currying or composition vs Ramda with currying and composition (no pluck) vs Lodash

Created: 4 years ago by: Guest

Jump to the latest result

HTML Preparation code:

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

Script Preparation code:

var data = _.range(100000).map(function(i) {
  return {
    counter: i
  }
});

function isOdd(num) {
  return num % 2 === 1;
}

function square(num) {
  return num * num;
}

function lessThanThreeDigits(num) {
  return num.toString().length < 3;
}

Tests:

JS native
var result = data .map(({counter}) => counter) .filter(isOdd) .map(square) .filter(lessThanThreeDigits)
Ramda with transducer
var transducer = R.compose ( R.map(R.prop('counter')), R.filter(isOdd), R.map(square), R.filter(lessThanThreeDigits), ); var result = R.transduce ( transducer, (acc, val) => { acc.push(val); return acc; }, [], data, );
Ramda with currying and composition
var result = R.pipe( R.pluck('counter'), R.filter(isOdd), R.map(square), R.filter(lessThanThreeDigits) )(data);
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 (no pluck)
var result = R.pipe( R.map (({counter}) => counter), R.filter(isOdd), R.map(square), R.filter(lessThanThreeDigits) )(data);
Lodash
var result = _.chain(data) .map('counter') .filter(isOdd) .map(square) .filter(lessThanThreeDigits) .value();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
JS native
Ramda with transducer
Ramda with currying and composition
Ramda without relying on currying or composition
Ramda with currying and composition (no pluck)
Lodash

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 llama3.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

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

**Benchmark Overview**

The benchmark compares the performance of four JavaScript libraries: Ramda, Lodash, and two styles of native JavaScript (JS native). The task is to process an array of objects, filtering out odd numbers, squaring them, and returning values with less than three digits.

**Library and Syntax Explanation**

1. **Ramda**: A functional programming library for JavaScript. It provides a concise way to perform operations on arrays and objects using a transducer-based syntax.
2. **Lodash**: A utility library that provides a wide range of functions for tasks such as string manipulation, array manipulation, and more.

**JS Native (JavaScript)**

This option uses only native JavaScript features and syntax, without any external libraries.

**Options Compared**

The benchmark compares the performance of:

1. **Ramda with Transducer**: Uses Ramda's transducer-based syntax to process the data.
2. **Ramda with Currying and Composition**: Uses Ramda's curried functions and composition feature to process the data.
3. **Ramda without Relying on Currying or Composition**: A variation of the previous option that uses a different approach, but still leverages Ramda's syntax.
4. **Lodash**: Uses Lodash's pipeline-based syntax to process the data.

**Pros and Cons**

* **JS Native (JavaScript)**:
	+ Pros: No external dependencies, native performance.
	+ Cons: Requires manual looping and conditionals, can be less efficient due to overhead of JavaScript engine.
* **Ramda with Transducer**:
	+ Pros: Compact and expressive syntax, easy to read and maintain.
	+ Cons: May have higher overhead due to the transducer mechanism.
* **Ramda with Currying and Composition**:
	+ Pros: More concise than traditional functional programming, easier to chain operations.
	+ Cons: Can be less readable for those unfamiliar with curried functions and composition.
* **Lodash**:
	+ Pros: Wide range of utility functions, easy to use and understand.
	+ Cons: May have higher overhead due to the pipeline syntax.

**Performance Results**

The benchmark results show that Ramda's transducer-based syntax (option 1) is the fastest, followed closely by Lodash. The native JavaScript option (option 3) is slower, while the two Ramda options with currying and composition are significantly slower than the first one.

Overall, the benchmark suggests that Ramda's transducer-based syntax can provide a good balance between performance and readability, making it a popular choice among developers. Lodash, on the other hand, excels at providing a wide range of utility functions, but may have higher overhead due to its pipeline syntax.

Related benchmarks: