Benchmark: Ramda vs. Lodash

Ramda 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: Lodash vs Ramda without relying on currying or composition vs Ramda with currying and composition

Created: 6 years ago by: Guest

Jump 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);

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

Autogenerated LLM Summary (model llama3.1:latest, generated one month ago):

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**Benchmark Overview**

The provided JSON represents a benchmark test comparing the performance of three approaches: Lodash, Ramda (with and without currying/composition), and "native" JavaScript, on the same task. The task involves:

1. Pulling the `counter` property from each item in an array.
2. Filtering out odd items.
3. Squaring them.
4. Returning those squared values that have less than two digits.

**Test Cases**

We have three test cases:

### 1. Lodash

This approach uses the popular utility library Lodash to perform the task. The benchmark definition code is:
```javascript
var result = _.chain(data)
  .map('counter')
  .filter(isOdd)
  .map(square)
  .filter(lessThanThreeDigits)
  .value();
```
Here, we're using the `_.chain` method to create a chain of operations on the `data` array.

**Pros**: Lodash is a widely-used and well-maintained library. Its methods are often more concise than equivalent native JavaScript code.
**Cons**: The use of a third-party library might introduce additional overhead, especially if the library itself has performance issues.

### 2. Ramda without currying/composition

This approach uses the functional programming library Ramda to perform the task. The benchmark definition code is:
```javascript
var result = R.filter(lessThanThreeDigits,
  R.map(square,
    R.filter(isOdd,
      R.pluck('counter', data))));
```
Here, we're using the `R.pipe` method to compose the operations on the `data` array.

**Pros**: Ramda provides a concise way to express complex data transformations.
**Cons**: The use of currying/composition can make the code harder to read and understand for those not familiar with functional programming concepts.

### 3. Ramda with currying/composition

This approach is similar to the previous one, but uses the `R.pipe` method to compose the operations on the `data` array in a more explicit way.
```javascript
var result = R.pipe(
  R.pluck('counter'),
  R.filter(isOdd),
  R.map(square),
  R.filter(lessThanThreeDigits)
)(data);
```
**Pros**: The use of currying/composition can make the code easier to read and understand, especially for complex transformations.
**Cons**: The explicit piping of operations can lead to more verbose code.

### Native JavaScript

The "native" approach is not explicitly represented in the provided JSON. However, it would involve using native JavaScript methods (e.g., `Array.prototype.map`, `Array.prototype.filter`) to perform the task.

**Pros**: Using native JavaScript methods ensures that you're not introducing additional overhead from a third-party library.
**Cons**: Native JavaScript code might be more verbose and harder to read, especially for complex transformations.

**Other Alternatives**

Some other alternatives for performing this task include:

* Using Array.prototype.reduce
* Implementing custom iteration functions using loops
* Utilizing higher-order functions like `map`, `filter`, and `forEach` from the Array prototype

Keep in mind that these approaches might have their own trade-offs, such as performance implications or code readability.

**Conclusion**

The provided benchmark compares three different approaches to performing a specific task: Lodash, Ramda (with and without currying/composition), and "native" JavaScript. Each approach has its pros and cons, which should be considered when choosing the best method for your use case.

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.139 Safari/537.36

Browser/OS: Chrome 66 on Linux

View result in a separate tab

Test name	Executions per second
Lodash	786.2 Ops/sec
Ramda without relying on currying or composition	527.5 Ops/sec
Ramda with currying and composition	511.2 Ops/sec

Related benchmarks:

Ramda 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: Lodash vs Ramda without relying on currying or composition vs Ramda with currying and composition

Created: 6 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.1:latest, generated one month ago):