Benchmark: Ramda vs. Lodash 3

Ramda vs. Lodash 3 (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: 5 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/3.10.1/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) .pluck('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

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:68.0) Gecko/20100101 Firefox/68.0

Browser/OS: Firefox 68 on Mac OS X 10.14

View result in a separate tab

Test name	Executions per second
Lodash	1588.1 Ops/sec
Ramda without relying on currying or composition	696.8 Ops/sec
Ramda with currying and composition	414.1 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

**Benchmark Overview**

The benchmark compares the performance of three approaches for filtering, mapping, and squaring elements in an array:

1. Lodash (with chaining)
2. Ramda without relying on currying or composition
3. Ramda with currying and composition

**Options Compared**

The options being compared are the different ways to perform the following operations:

* Filtering out odd items from the array (`isOdd` function)
* Squaring the filtered items (`square` function)
* Checking if the squared value has less than two digits (`lessThanThreeDigits` function)

**Pros and Cons of Each Approach**

1. **Lodash (with chaining)**:
	* Pros: Easy to read, concise, and well-documented.
	* Cons: May lead to slow performance due to overhead from method calls and object lookups.
2. **Ramda without relying on currying or composition**:
	* Pros: More efficient than Lodash, as it uses primitive functions and avoids function call overhead.
	* Cons: Less readable and less concise than Lodash.
3. **Ramda with currying and composition**:
	* Pros: Highly optimized for performance, as it leverages JavaScript's functional programming features.
	* Cons: Steeper learning curve due to the use of currying and composition.

**Library Used**

The `ramda` library is used in two test cases:

1. `R.filter(lessThanThreeDigits,\r\n  R.map(square,\r\n    R.filter(isOdd,\r\n      R.pluck('counter', data))))`
2. `var result = R.pipe(\r\n  R.pluck('counter'),\r\n  R.filter(isOdd),\r\n  R.map(square),\r\n  R.filter(lessThanThreeDigits)\r\n)(data);`

The `lodash` library is used in the first test case:

1. `var result = _.chain(data)\r\n  .pluck('counter')\r\n  .filter(isOdd)\r\n  .map(square)\r\n  .filter(lessThanThreeDigits)\r\n  .value();`

**Special JS Feature/Syntax**

The benchmark uses the `R` and `_` symbols to prefix Ramda functions, which is a common convention in functional programming. This allows for concise and readable code.

The test cases also use the `pipe` function from Ramda, which is a higher-order function that applies a series of transformations to an input value.

**Other Alternatives**

If you want to try alternative libraries or approaches, here are some options:

1. **Mocha**: A popular testing framework for JavaScript.
2. **Benchmarking libraries like Benchmark.js or jsbench**:
	* These libraries provide a simple way to measure the performance of your code and compare it with other implementations.
3. **Lodash alternatives like `lodash-es` or `fast-lodash`**:
	* These libraries offer optimized versions of Lodash functions for better performance.
4. **Ramda alternatives like `ramda-core` or `esm-ramda`**:
	* These libraries provide the core functionality of Ramda without the additional features and dependencies.

Keep in mind that each alternative has its own strengths and weaknesses, so it's essential to choose the one that best fits your project requirements.

Related benchmarks:

Ramda vs. Lodash 3 (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: 5 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 2 months ago):