Benchmark: Ramda vs. Lodash + Immutable

Ramda vs. Lodash + Immutable (version: 1)

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 Immutable

Created: 7 years ago by: Registered User

Jump to the latest result

HTML Preparation code:

<script src="https://unpkg.com/ramda@0.25.0/dist/ramda.min.js"></script>
<script src="https://unpkg.com/lodash@4.17.10/lodash.js"></script>
<script src="https://unpkg.com/immutable@4.0.0-rc.9/dist/immutable.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);
Immutable
var result = Immutable .Seq(data) .map(({ counter }) => counter) .filter(isOdd) .map(square) .filter(lessThanThreeDigits) .toJS()

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
Immutable

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.5845.713 YaBrowser/23.9.5.713 (corp) Yowser/2.5 Safari/537.36

Browser/OS: Yandex Browser 23 on Windows

View result in a separate tab

Test name	Executions per second
Lodash	2672.0 Ops/sec
Ramda without relying on currying or composition	1266.4 Ops/sec
Ramda with currying and composition	1162.2 Ops/sec
Immutable	2223.5 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!

**Overview**

The provided JSON represents a benchmarking test for comparing the performance of different libraries: Lodash, Ramda, and Immutable.js. The test involves pulling a "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.

**Library Explanation**

* **Lodash**: A popular JavaScript library for functional programming. It provides a vast number of functions and methods to manipulate arrays, objects, and more.
* **Ramda**: Another functional programming library, but with a stronger focus on purity and immutability. It provides a smaller set of functions than Lodash, but they are more concise and expressive.
* **Immutable.js**: A library for working with immutable data structures. It provides a way to create objects that cannot be changed once created.

**Options Compared**

The test compares four different approaches:

1. **Lodash Chain Method**: This approach uses the `chain` method from Lodash to chain multiple functions together.
2. **Ramda without currying or composition**: This approach uses Ramda's `filter`, `map`, and `pluck` functions directly, without using currying or composition.
3. **Ramda with currying and composition**: This approach uses Ramda's `pipe` function to curry and compose multiple functions together.
4. **Immutable.js**: This approach uses Immutable.js's `Seq` data structure to manipulate the array.

**Pros and Cons**

* **Lodash Chain Method**: Pros - easy to read and maintain, flexible. Cons - can be slow due to the overhead of chain method calls.
* **Ramda without currying or composition**: Pros - concise and expressive, no additional function calls required. Cons - less readable than other approaches, may require more memory due to function object creation.
* **Ramda with currying and composition**: Pros - concise and expressive, can be faster than other approaches. Cons - requires understanding of Ramda's currying and composition features, may have performance overhead due to function object creation.
* **Immutable.js**: Pros - immutable data structures provide predictable behavior, no side effects. Cons - slower than other approaches due to the overhead of creating and manipulating immutable objects.

**Special JS Features**

The test uses some special JavaScript features:

* Currying: a technique where a function is transformed into a sequence of smaller functions.
* Composition: a technique where multiple functions are combined together to create a new function.

These features are not unique to Ramda, but are specific to the way it's used in this benchmark.

**Other Alternatives**

If you're interested in exploring other alternatives for functional programming or data manipulation in JavaScript, here are some options:

* **Lo-Dash**: another popular functional programming library.
* **Mary**: a minimalist alternative to Lodash and Ramda.
* **Fp.js**: a small, lightweight library for functional programming.

These libraries offer different trade-offs between conciseness, readability, and performance.

Related benchmarks: