Benchmark: Ramda vs. Lodash

Ramda vs. Lodash (version: 2)

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 Vanilla JS`

Created: 8 years ago by: Registered User

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 Preparation code:

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);
Vanilla JS
var result = data.map(i => i.counter) .filter(isOdd) .map(square) .filter(lessThanThreeDigits);

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
Vanilla JS

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 18_1_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1.1 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 18 on iOS 18.1.1

View result in a separate tab

Vanilla JS

6K/s

Lodash

3K/s

Ramda without relying on currying or composition

2K/s

Ramda with currying and composition

2K/s

View exact numbers

Test name	Executions per second
✓ Vanilla JS	6,007 Ops/sec
Lodash	2,702 Ops/sec
Ramda without relying on currying or composition	1,954 Ops/sec
Ramda with currying and composition	1,917 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 benchmark.

**Benchmark Purpose**

The benchmark compares the performance of four approaches to perform a specific task:

1.  Filtering, mapping, squaring, and filtering an array of numbers using Lodash (`_`).
2.  Using Ramda with two different styles: one without relying on currying or composition, and another with currying and composition.
3.  A vanilla JavaScript implementation.

**Options Compared**

The benchmark compares the performance of these four approaches:

*   **Lodash**: The original approach using `_.chain()` for chaining operations.
*   **Ramda without currying/composition**: Using Ramda's functional programming features directly, without relying on currying or composition.
*   **Ramda with currying and composition**: Using Ramda's currying and composition features to create a pipeline of operations.
*   **Vanilla JavaScript**: A straightforward implementation using only native JavaScript.

**Pros and Cons**

Here's a brief overview of the pros and cons of each approach:

*   **Lodash**:
    *   Pros: Easy to read, maintainable code. Lodash provides a simple and consistent API for functional programming.
    *   Cons: Can be slower than optimized implementations due to its object-based design.
*   **Ramda without currying/composition**: 
    *   Pros: Fast execution times, minimal dependencies. Ramda's functional programming features provide an efficient way to process data.
    *   Cons: Steeper learning curve due to its unique syntax and concepts (e.g., pipes, currying).
*   **Ramda with currying and composition**:
    *   Pros: Optimized performance, concise code. Currying and composition enable a more functional programming style without sacrificing readability.
    *   Cons: Requires a good understanding of functional programming concepts and Ramda's API.
*   **Vanilla JavaScript**:
    *   Pros: Fast execution times, minimal dependencies. Native JavaScript is optimized for performance and flexibility.
    *   Cons: Can be error-prone due to lack of type safety and explicitness.

**Libraries and Special Features**

In this benchmark:

*   Lodash (`_`) is used as the library for functional programming features.
*   Ramda is used with two different styles:
    *   **Ramda without currying/composition**: Uses its `filter()`, `map()`, and other methods directly, which may not be optimized.
    *   **Ramda with currying and composition**: Utilizes its pipe (`pipe()`) and curry (`curry()`) features to create a pipeline of operations, which should provide better performance.

**Other Considerations**

The benchmark focuses on the specific task of filtering, mapping, squaring, and filtering an array of numbers. Other considerations that might influence the results include:

*   **Language overhead**: Each implementation has its own language overhead (e.g., parsing, type checking).
*   **Browser/Device differences**: The test data is executed on a Chrome Mobile device running Android 11. Different browsers or devices may exhibit varying performance due to hardware and software factors.

**Alternatives**

Some alternative approaches might include:

*   Using other libraries like Lo-Dash or Antimer (similar to Ramda).
*   Implementing the task using different functional programming paradigms (e.g., imperative, object-oriented).
*   Considering alternative optimization techniques (e.g., memoization, parallel processing).