Benchmark: Ramda vs. Lodash 2021 v2

Ramda vs. Lodash 2021 v2 (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: 2 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) .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.2:3b, generated one month ago):

LLMs can make mistakes. Check important info.

Let's dive into the explanation.

**Benchmark Overview**

The provided JSON represents a benchmark test between three JavaScript libraries: Lodash, Ramda (without relying on currying or composition), and Ramda with currying and composition. The goal of this benchmark is to compare the performance of each library in executing a specific task: 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.

**Benchmark Options**

There are three test cases:

1. **Lodash**: Uses Lodash's `chain()` method to create a pipeline of functions.
2. **Ramda without relying on currying or composition**: Uses Ramda's standalone functions (`filter()`, `map()`, etc.) without composing them together.
3. **Ramda with currying and composition**: Uses Ramda's curried functions (`R.filter()`, `R.map()`, etc.) composed together using the `pipe()` function.

**Pros and Cons**

Here's a brief summary of the pros and cons of each approach:

* **Lodash (Chain Method)**:
	+ Pros: Easy to read, maintainable code; provides a clear pipeline of operations.
	+ Cons: May lead to performance issues due to unnecessary intermediate results.
* **Ramda without relying on currying or composition**:
	+ Pros: Simple and straightforward code; avoids potential overhead of currying and composition.
	+ Cons: Code can become verbose and less readable, especially for complex operations.
* **Ramda with currying and composition**:
	+ Pros: Can lead to concise and expressive code; takes advantage of Ramda's functional programming features.
	+ Cons: May be harder to read and understand for beginners or those not familiar with currying and composition.

**Library Descriptions**

1. **Lodash**: A popular JavaScript utility library that provides a wide range of functions for data manipulation, object creation, and more. In this benchmark, Lodash's `chain()` method is used to create a pipeline of operations.
2. **Ramda**: Another popular functional programming library for JavaScript that offers a different set of tools and abstractions compared to Lodash. Ramda provides curried functions (`R.filter()`, `R.map()`) that can be composed together using the `pipe()` function.

**Special JS Features or Syntax**

None mentioned in the provided benchmark code, but note that some versions of JavaScript (e.g., ES6+) introduce new features like arrow functions (`=>`), destructuring (`const { x: y } = obj;`), and async/await syntax (`async function() { ... }`). If a benchmark tests for specific features, they might require additional setup or modifications to the code.

**Alternatives**

Other JavaScript libraries that provide similar functionality to Lodash and Ramda include:

* **Underscore.js**: A functional programming library that offers many of the same functions as Lodash.
* **Futhark**: A functional programming language for JavaScript that compiles to native machine code, offering performance benefits compared to interpreted languages like Ramda.

Keep in mind that this is not an exhaustive list, and other libraries might be suitable depending on specific use cases or requirements.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36

Browser/OS: Chrome 92 on Mac OS X 10.14.6

View result in a separate tab

Test name	Executions per second
Lodash	2275.6 Ops/sec
Ramda without relying on currying or composition	873.1 Ops/sec
Ramda with currying and composition	820.9 Ops/sec

Related benchmarks:

Ramda vs. Lodash 2021 v2 (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: 2 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 one month ago):