Benchmark: Ramda vs. Lodash vs. VanillaJS 2022

Ramda vs. Lodash vs. VanillaJS 2022 (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 VanillaJS functional style vs VanillaJS procedural

Created: 3 years ago by: Guest

Jump to the latest result

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.28.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 = [];
for (var i = 0; i < 10000; i++) {
     data.push({ counter: i });
}

function isOdd(num) {
  return num % 2 === 1;
}

function square(num) {
  return num * num;
}

function lessThanThreeDigits(num) {
  return num.toString().length < 3;
}

var expected = data.map(o => o.counter).filter(isOdd).map(square).filter(lessThanThreeDigits);

Tests:

Lodash
var result = _.chain(data) .map(d => _.get(d, '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);
VanillaJS functional style
var result = data.map(o => o.counter).filter(isOdd).map(square).filter(lessThanThreeDigits);
VanillaJS procedural
var result = new Array(); for (var i = 0; i < data.length; i++) { var c = data[i].counter; if (isOdd(c)) { var r = square(c); if (lessThanThreeDigits(r)) { result.push(r); } } }

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
VanillaJS functional style
VanillaJS procedural

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 143 on Windows

View result in a separate tab

Test name	Executions per second
Lodash	2972.8 Ops/sec
Ramda without relying on currying or composition	3433.9 Ops/sec
Ramda with currying and composition	3151.1 Ops/sec
VanillaJS functional style	4487.0 Ops/sec
VanillaJS procedural	11721.5 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested.

**Benchmark Definition**

The benchmark compares the performance of three approaches:

1. **Ramda**: A functional programming library for JavaScript.
2. **Lodash**: Another popular utility library for JavaScript.
3. **VanillaJS**: Native JavaScript implementation without any external libraries.

**Test Cases**

There are four test cases, each representing a different approach:

1. **Lodash**: Uses the `lodash` library to chain methods together.
	* Pros: Easy to read and maintain, well-documented, widely used.
	* Cons: Adds external dependency, can be slower due to function call overhead.
2. **Ramda without relying on currying or composition**: Directly applies Ramda functions to the data.
	* Pros: Fast, lightweight, no external dependencies.
	* Cons: Can be harder to read and maintain, less well-documented than Lodash.
3. **Ramda with currying and composition**: Uses Ramda's functional programming features (currying and composition) to process the data.
	* Pros: Efficient, concise, and expressive code.
	* Cons: Steeper learning curve, may be harder for beginners to understand.
4. **VanillaJS functional style**: Uses native JavaScript functions to achieve a similar result.
	* Pros: Easy to understand, no external dependencies.
	* Cons: May be slower than the other approaches due to function call overhead.

**Ramda and Lodash**

In both cases, Ramda is used as an alternative to Lodash. This suggests that the benchmark is testing the performance of different libraries for a specific task.

**Special JS feature or syntax**

There are no special JavaScript features or syntaxes being tested in this benchmark. The code is written in standard JavaScript and uses only built-in functions.

**Other alternatives**

If you're looking for alternative libraries to Lodash, consider:

* **Immutable.js**: A library that provides immutable data structures and functions.
* **Peano.js**: Another library that focuses on functional programming concepts.
* **Underscore.js**: A utility library similar to Lodash but with a different syntax.

Keep in mind that each library has its strengths and weaknesses, and the choice of which one to use depends on your specific needs and preferences.

Related benchmarks: