Benchmark: Ramda vs. Lodash

Ramda vs. Lodash (version: 0) Benchmark.js

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`

Created: 8 years ago by: Guest

Go to the latest result

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.25.0/ramda.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.4/lodash.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.10/lodash.fp.min.js"></script>

Script Preparation code:

var fp = _.noConflict();

var data = _.range(10000).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:

Lodash
var result = _.chain(data) .map('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);

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

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Mobile Safari/537.36

Browser/OS: Chrome Mobile 126 on Android

View result in a separate tab

Lodash

2K/s

Ramda without relying on currying or composition

1K/s

Ramda with currying and composition

914/s

View exact numbers

Test name	Executions per second
✓ Lodash	2,044 Ops/sec
Ramda without relying on currying or composition	1,010 Ops/sec
Ramda with currying and composition	914 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**Benchmark Overview**

The benchmark compares the performance of three approaches to perform the same task using Lodash, Ramda, and native JavaScript:

1. **Lodash**: Uses the `chain` method to create a pipeline of operations.
2. **Ramda without relying on currying or composition**: Directly calls functions without using currying (a technique where functions are applied in a specific order) or composition (applying functions to results).
3. **Ramda with currying and composition**: Uses the `pipe` function to create a pipeline of operations, which is a common pattern in functional programming.

**Options Compared**

The benchmark compares three options:

1. Lodash (`_`)
2. Ramda without relying on currying or composition (e.g., `R.filter`, `R.map`)
3. Ramda with currying and composition (e.g., `R.pipe`)

**Pros and Cons of Each Approach**

* **Lodash**: Pros:
	+ Easy to read and maintain
	+ Well-known library
Cons:
	+ Can be slower than other approaches due to overhead from the `chain` method
* **Ramda without relying on currying or composition**: Pros:
	+ May perform better since it avoids the overhead of `chain`
Cons:
	+ Less readable and maintainable, especially for complex pipelines
* **Ramda with currying and composition**: Pros:
	+ Often performs well due to optimized function calls
Cons:
	+ Can be less readable and maintainable than Lodash

**Library Usage**

In the benchmark, Ramda is used in two ways:

1. Without relying on currying or composition (`R.filter`, `R.map`)
2. With currying and composition (`R.pipe`)

The `_` symbol refers to Lodash.

**JavaScript Features/Syntax**

There are no special JavaScript features or syntax used in this benchmark. It only uses standard JavaScript functions (e.g., `map`, `filter`) and a few custom functions (`isOdd`, `square`, `lessThanThreeDigits`).

**Alternatives**

For those interested in alternative libraries, here are some options:

1. **Underscore.js**: Similar to Lodash but with a smaller footprint.
2. **Jquery**: Not typically used for performance-critical tasks, but can be useful for DOM manipulation and event handling.
3. **Purescript**: A functional programming language that compiles to JavaScript.

Keep in mind that the choice of library or approach depends on your specific use case and requirements.

In conclusion, this benchmark provides a fair comparison of three approaches to perform a task using Lodash, Ramda, and native JavaScript. It highlights the pros and cons of each approach, helping developers understand which one might be best suited for their specific needs.