Benchmark: Ramda vs. Lodash 6

Ramda vs. Lodash 6 (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

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.1/ramda.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.20/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) .pick('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: 3 years ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:84.0) Gecko/20100101 Firefox/84.0

Browser/OS: Firefox 84 on Mac OS X 10.15

View result in a separate tab

Test name	Executions per second
Lodash	131904.7 Ops/sec
Ramda without relying on currying or composition	210.7 Ops/sec
Ramda with currying and composition	120.6 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation of the provided benchmark.

**Benchmark Overview**

The benchmark compares the performance of Lodash, Ramda, and native JavaScript in performing a specific task: filtering out odd items from an array, squaring them, and returning values with less than two digits. The task is implemented in three different ways using Lodash (version 6) and two styles of Ramda.

**Options Compared**

The benchmark compares the following options:

1. **Lodash (no optimization)**: Uses the `chain()` method to perform the operation.
2. **Ramda without relying on currying or composition**: Uses a functional programming style, but does not use any of Ramda's composition functions like `pipe()`.
3. **Ramda with currying and composition**: Uses `pipe()` to compose the operations.

**Pros and Cons**

* **Lodash (no optimization)**:
	+ Pros: Easy to read and understand, straightforward implementation.
	+ Cons: May be less efficient due to the use of a chain method.
* **Ramda without relying on currying or composition**:
	+ Pros: Still uses a functional programming style, which can be beneficial for readability.
	+ Cons: May not leverage Ramda's optimized functions and methods.
* **Ramda with currying and composition**:
	+ Pros: Can lead to more concise and expressive code, potentially leading to better performance due to the use of optimized functions.
	+ Cons: Requires a good understanding of functional programming concepts and Ramda's API.

**Library Usage**

The benchmark uses two libraries:

1. **Lodash**: A popular utility library for JavaScript that provides a wide range of functional programming helpers.
2. **Ramda**: A functional programming library that provides a more concise and expressive way to work with data, but requires a good understanding of its API.

**Special JS Feature or Syntax**

There are no special JS features or syntax used in this benchmark.

**Benchmark Preparation Code**

The preparation code sets up the test data by generating an array of 10,000 objects with a "counter" property, and defines three helper functions: `isOdd()`, `square()`, and `lessThanThreeDigits()`.

**Individual Test Cases**

Each test case is defined as a separate benchmark that measures the performance of one of the three options compared above. The test cases use the same data structure but implement the task in different ways using Lodash, Ramda (with and without currying), or native JavaScript.

**Latest Benchmark Results**

The latest results show the performances of each option for each browser instance tested. However, I won't display the exact values here.

**Other Alternatives**

If you're interested in exploring alternative libraries or approaches, here are a few suggestions:

1. **Underscore.js**: Another popular utility library that provides similar functionality to Lodash.
2. **Soy**: A small and fast functional programming library that provides some of the same features as Ramda.
3. **Native JavaScript**: You can also implement this benchmark using pure native JavaScript, which would likely be the slowest option due to its lack of optimization.

I hope this explanation helps!

Related benchmarks:

Ramda vs. Lodash 6 (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

Created: 4 years ago by: Guest

Jump to the latest result

Lodash

Ramda without relying on currying or composition

Ramda with currying and composition

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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