Benchmark: Ramda vs. Lodash (forked)

Ramda vs. Lodash (forked) (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: Registered User

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.5/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.compose( R.filter(lessThanThreeDigits), R.map(square), R.filter(isOdd), R.pluck('counter') )(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: 2 years ago)

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 17_2_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 17 on iOS 17.2.1

View result in a separate tab

Test name	Executions per second
Lodash	468823.7 Ops/sec
Ramda without relying on currying or composition	1599.1 Ops/sec
Ramda with currying and composition	1503.6 Ops/sec

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

LLMs can make mistakes. Check important info.

**What is being tested?**

MeasureThat.net is testing the performance of three different approaches to perform a data processing task:

1. **Lodash**: A popular JavaScript library for functional programming.
2. **Ramda without relying on currying or composition**: Ramda, another popular JavaScript functional programming library.
3. **Ramda with currying and composition**: An alternative way of using Ramda by composing functions together.

The task is to take an array of objects with a "counter" property, filter out the odd items, square the remaining numbers, and then return only those squared values that have less than 3 digits.

**Options being compared**

* **Lodash vs. Ramda**: Two popular JavaScript functional programming libraries.
	+ Pros:
		- Lodash has a larger community and more extensive documentation.
		- Ramda is known for its concise and expressive code, making it easier to write composable functions.
	+ Cons:
		- Lodash can be heavier due to its larger size and additional dependencies.
		- Ramda's API might require more learning for those familiar with Lodash.
* **Two styles of Ramda**:
	+ **Without relying on currying or composition**: Uses traditional function calls instead of curried functions.
	+ **With currying and composition**: Uses functional programming principles to compose smaller functions together.

Pros:

* With currying, the code can be more concise and easier to read.
* Composition allows for a more modular approach to problem-solving.

Cons:

* Requires understanding of functional programming concepts.
* May have performance implications due to function creation overhead.

**Library usage**

In this benchmark, both Lodash and Ramda are used to perform the data processing task. The main difference is in their approach: Lodash uses a more traditional imperative style, while Ramda (both versions) uses a functional programming style.

Ramda's `filter`, `map`, and `compose` functions are used extensively throughout the benchmark. These functions provide a high-level abstraction for common data processing tasks, making it easier to write concise code.

**Special JS feature or syntax**

None mentioned in this specific benchmark.

**Alternative approaches**

Other alternatives for performing similar data processing tasks could include:

* Vanilla JavaScript: Using native JavaScript functions like `filter`, `map`, and `reduce` without any libraries.
* Other functional programming libraries: Such as Underscore.js, Jest, or Svelte's reactive state management.
* Stream processing libraries: Like RxJS (for reactive streams) or Node.js streams.

Keep in mind that each alternative has its own trade-offs, performance characteristics, and learning curve.

Related benchmarks: