Benchmark: Ramda vs. Lodash - New

Ramda vs. Lodash - New (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: 3 years ago by: Registered User

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.21/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

Autogenerated LLM Summary (model llama3.2:3b, generated 25 days ago):

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

**Benchmark Overview**

The provided benchmark compares the performance of three approaches: Lodash, Ramda with currying and composition, and Ramda without relying on currying or composition. The test case is designed to measure how quickly these libraries can process a large array of objects, filtering out odd items, squaring even items, and returning only those with less than two digits.

**Options Compared**

The three options being compared are:

1. **Lodash**: A popular JavaScript utility library that provides a wide range of functions for tasks like data manipulation, string manipulation, and more.
2. **Ramda (with currying and composition)**: A functional programming library for JavaScript that allows you to compose functions together to create new functions with more complex behavior. Currying is a technique where a function takes arguments in a different order than its typical usage.
3. **Ramda (without relying on currying or composition)**: This option uses Ramda's built-in functions without composing them into a single pipeline.

**Pros and Cons**

Here are the pros and cons of each approach:

1. **Lodash**:
	* Pros: Easy to use, widely adopted, and has a large community.
	* Cons: Can be slower due to its overhead and the need for function calls.
2. **Ramda (with currying and composition)**:
	* Pros: Can lead to more efficient code due to pipelining and less function call overhead.
	* Cons: Requires a steeper learning curve, as it introduces functional programming concepts like currying and composition.
3. **Ramda (without relying on currying or composition)**:
	* Pros: Still uses Ramda's optimized functions under the hood, but without the additional complexity of currying and composition.
	* Cons: May not be as efficient as the pipelined approach, due to repeated function calls.

**Library Usage**

In this benchmark, **Lodash** is used for its `chain` method, which allows for a pipeline-like approach. Ramda uses its own `pipe` function to compose functions together, and provides an alternative implementation without currying or composition.

**Special JavaScript Features/Syntax**

There are no special JavaScript features or syntax mentioned in this benchmark that would require specific knowledge of the language.

**Alternatives**

Other alternatives for similar microbenchmarking could include:

1. **Array.prototype.reduce**: This method can be used to process arrays, but it might not be as efficient as pipelining functions.
2. **Native JavaScript Array Methods**: Some native methods like `filter()`, `map()`, and `reduce()` can also be used for similar tasks.

Overall, the benchmark highlights the trade-offs between using a library with optimized functions (Lodash) versus composing functions together to create a pipeline (Ramda).

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.164 Safari/537.36

Browser/OS: Chrome 91 on Windows

View result in a separate tab

Test name	Executions per second
Lodash	619766.2 Ops/sec
Ramda without relying on currying or composition	934.9 Ops/sec
Ramda with currying and composition	942.7 Ops/sec

Related benchmarks:

Ramda vs. Lodash - New (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: 3 years ago by: Registered User

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 25 days ago):