Benchmark: Ramda vs. Lodash v2

Ramda vs. Lodash 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.28.0/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) .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.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: 2 years ago)

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.60 Safari/537.36

Browser/OS: Chrome 100 on Linux

View result in a separate tab

Test name	Executions per second
Lodash	260927.7 Ops/sec
Ramda without relying on currying or composition	931.7 Ops/sec
Ramda with currying and composition	871.1 Ops/sec

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

LLMs can make mistakes. Check important info.

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

**Benchmark Overview**

The benchmark measures the performance of three different approaches to perform a specific task:

1. Lodash (a popular JavaScript utility library)
2. Ramda (another popular JavaScript functional programming library) with two variations:
	* "Ramda without relying on currying or composition" (uses imperative-style functions)
	* "Ramda with currying and composition" (uses curried and composed functions)

**Task Description**

The task is to:

1. Create an array of 10,000 objects with a "counter" property
2. Filter out the odd-numbered items in the array
3. Square the remaining even-numbered items
4. Return the squared values that have less than two digits

**Library and Syntax Used**

* Lodash: used for its `chain()` function to compose a series of operations, `pick()` to extract a specific property from an object, `filter()` to remove elements based on a condition, `map()` to apply a transformation to each element, and `value()` to return the final result
* Ramda: used as a functional programming library. The "Ramda without relying on currying or composition" variation uses imperative-style functions, while the "Ramda with currying and composition" variation uses curried and composed functions.

**Approach Comparison**

The three approaches are compared in terms of performance:

1. **Lodash**: uses the `chain()` function to compose a series of operations, which can be slower than using individual functions due to the overhead of function calls.
2. **Ramda without relying on currying or composition**: uses imperative-style functions, which can be faster than curried and composed functions due to fewer function call overheads.
3. **Ramda with currying and composition**: uses curried and composed functions, which can be slower than using imperative-style functions due to the additional overhead of curried functions.

**Pros and Cons**

* Lodash:
	+ Pros: easy to use, well-documented, and widely adopted
	+ Cons: may have performance overhead due to function call chaining
* Ramda without relying on currying or composition:
	+ Pros: faster than using curried and composed functions, more control over code execution
	+ Cons: requires more knowledge of functional programming concepts, can be harder to read and maintain
* Ramda with currying and composition:
	+ Pros: concise and expressive code, easy to chain operations together
	+ Cons: may have performance overhead due to function call chaining, requires knowledge of curried functions

**Other Alternatives**

* Other JavaScript libraries that provide similar functionality to Lodash and Ramda include:
	+ Underscore.js (similar to Lodash)
	+ Lo-Dash (a variant of Lodash with additional features)
	+ Immer.js (a library for functional updates to objects)

Overall, the benchmark highlights the importance of considering performance when choosing a JavaScript library or approach. While ease of use and readability are essential, faster execution times can be critical in certain applications.

Related benchmarks:

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