Benchmark: Ramda vs. Lodash correct

Ramda vs. Lodash correct (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: 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.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) .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 25 days ago):

LLMs can make mistakes. Check important info.

Let's dive into the benchmarking test.

**Benchmark Description**

The test compares the performance of three different approaches to perform a specific task:

1. Filtering, squaring, and filtering again on an array of objects using Lodash.
2. Using Ramda with two styles of implementation:
	* Without relying on currying or composition (i.e., applying functions sequentially).
	* With currying and composition (i.e., using higher-order functions to compose operations).

The task is to pull the "counter" property from each item in an array, filter out odd items, square them, then return those squared values that have less than two digits.

**Library Usage**

In the provided benchmark definition JSON, Lodash is used with its `chain()` method to perform a pipeline of operations on the data. Ramda is also used with its own set of functions and currying mechanics.

* `_.chain()`: A utility function in Lodash that allows chaining multiple methods together.
* `R.filter()`, `R.map()`, `R.pluck()`, and `R.pipe()`: Functions in Ramda for filtering, mapping, and transforming data. Ramda uses a functional programming style with currying.

**Special JavaScript Features**

None mentioned explicitly, but it's worth noting that the use of `var` instead of `let` or `const` might be an older syntax feature (before ES6).

**Benchmark Preparation Code Analysis**

The provided script preparation code defines:

* A data array `data` with 10,000 objects, each containing a "counter" property.
* Two helper functions: `isOdd()` to check if a number is odd and `square(num)` to square a number. The latter is not actually used in the benchmark, but its definition suggests that it's supposed to be used to square numbers.

The HTML preparation code includes links to Ramda and Lodash libraries for use in the test.

**Test Cases**

There are three test cases:

1. **Lodash**: Uses `_.chain()` to perform a pipeline of operations on the data, filtering out odd items, squaring them, then returning those with less than two digits.
2. **Ramda without currying/composition**: Applies functions sequentially using Ramda's `R.filter()`, `R.map()`, and `R.pluck()` methods.
3. **Ramda with currying/composition**: Uses higher-order functions to compose operations, including `R.pipe()` to chain multiple transformations together.

**Pros and Cons**

* Lodash:
	+ Pros: Easy to read and maintain code; well-documented API.
	+ Cons: May have performance overhead due to the use of `chain()`.
* Ramda without currying/composition:
	+ Pros: Can be more efficient than using `pipe()` or higher-order functions.
	+ Cons: Code may look less concise or readable, especially for those unfamiliar with functional programming.
* Ramda with currying/composition:
	+ Pros: Can lead to more expressive and elegant code; can be more efficient by avoiding unnecessary function calls.
	+ Cons: May require more time and effort to understand the composed functions.

**Alternatives**

Other alternatives could include:

* Using ES6-style arrow functions or async/await for a different implementation of the task.
* Implementing the task using vanilla JavaScript without any libraries (although this might not be as readable or efficient).
* Using other functional programming libraries like Underscore.js or Purescript.

Latest run results:

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

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

Browser/OS: Chrome 96 on Windows

View result in a separate tab

Test name	Executions per second
Lodash	2343.1 Ops/sec
Ramda without relying on currying or composition	1278.3 Ops/sec
Ramda with currying and composition	1192.0 Ops/sec

Related benchmarks:

Ramda vs. Lodash correct (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: 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.2:3b, generated 25 days ago):