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 vs Lodash FP

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 src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.10/lodash.fp.min.js"></script>

Script Preparation code:

var fp = _.noConflict();

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);
Lodash FP
var result = fp.pipe( fp.map('counter'), fp.filter(isOdd), fp.map(square), fp.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
Lodash FP

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

The provided JSON represents a benchmark test for comparing the performance of three different libraries: Lodash, Ramda (without relying on currying or composition), and Ramda (with currying and composition). The test case is designed to measure the performance of each library when performing a specific task.

**What is being tested?**

The test case involves pulling the "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. This is done using different approaches for each library:

* Lodash: The `chain()` method is used to create a pipeline of functions that are executed in sequence.
* Ramda (without currying or composition): The `filter()`, `map()`, and `pluck()` methods are used separately to achieve the desired result.
* Ramda (with currying and composition): The `pipe()` function is used to compose multiple functions together, creating a single pipeline that is executed in sequence.

**Options compared**

The three options being compared are:

1. Lodash: Using the `chain()` method for a pipeline of functions.
2. Ramda (without currying or composition): Using separate methods (`filter()`, `map()`, and `pluck()`) to achieve the desired result.
3. Ramda (with currying and composition): Using the `pipe()` function to compose multiple functions together.

**Pros and cons**

Here are some pros and cons of each approach:

* Lodash: Advantages:
	+ Easy to use and read.
	+ Provides a concise way to create pipelines of functions.
	Disadvantages:
	+ May be less efficient than other approaches due to the overhead of the `chain()` method.
* Ramda (without currying or composition): Advantages:
	+ Can be more flexible and customizable than pipeline-based approaches.
	Disadvantages:
	+ Requires more boilerplate code and may be harder to read.
* Ramda (with currying and composition): Advantages:
	+ Provides a concise way to compose multiple functions together.
	Disadvantages:
	+ May be less readable or maintainable for complex pipelines.

**Library used in the test case**

The libraries being tested are:

1. Lodash: A utility library that provides a wide range of functions for working with data, including array manipulation and functional programming tools.
2. Ramda: A functional programming library that provides a set of higher-order functions for working with arrays and other data structures.

**Special JavaScript features or syntax**

The test case uses the following special JavaScript features or syntax:

1. Currying: The use of `R.filter()` and `R.map()` to create curried functions.
2. Composition: The use of `R.pipe()` to compose multiple functions together.

**Alternatives**

There are other alternatives to Lodash and Ramda that can be used for functional programming in JavaScript, including:

1. Underscore.js: Another utility library that provides a wide range of functions for working with data.
2. FP.js: A minimalist functional programming library that provides a set of higher-order functions for working with arrays and other data structures.

In summary, the test case is designed to compare the performance of three different libraries (Lodash, Ramda without currying or composition, and Ramda with currying and composition) when performing a specific task. The results provide insight into the efficiency and readability of each approach, as well as the benefits and drawbacks of using pipeline-based versus functional programming approaches.

Latest run results:

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

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

Browser/OS: Chrome 86 on Windows

View result in a separate tab

Test name	Executions per second
Lodash	1303.4 Ops/sec
Ramda without relying on currying or composition	1440.2 Ops/sec
Ramda with currying and composition	1259.9 Ops/sec
Lodash FP	1297.9 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 vs Lodash FP

Created: 6 years ago by: Guest

Jump to the latest result

Lodash

Ramda without relying on currying or composition

Ramda with currying and composition

Lodash FP

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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