Benchmark: Ramda vs. Lodash updated

Ramda vs. Lodash updated (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: 3 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 27 days ago):

LLMs can make mistakes. Check important info.

Let's break down the benchmark test cases.

**Benchmark Overview**

The test compares the performance of three approaches to perform the same task:

1. Using Lodash (a popular JavaScript utility library)
2. Using Ramda without relying on currying or composition (Ramda is another popular functional programming library for JavaScript)
3. Using Ramda with currying and composition

**Task Description**

The test pulls a "counter" property from each item in an array, filters out odd items, squares the remaining numbers, and returns those squared values that have less than two digits.

**Options Compared**

1. Lodash: Uses its `chain()` method to create a pipeline of operations, filtering, mapping, and squaring numbers.
2. Ramda without currying or composition: Uses individual functions like `filter()`, `map()`, and `square()` without creating a pipeline.
3. Ramda with currying and composition: Uses curried functions (functions that return other functions) and composition (applying functions in a specific order) to achieve the same result.

**Pros and Cons**

1. Lodash:
	* Pros: Easy to read and maintain, concise code.
	* Cons: May be slower due to the overhead of creating a pipeline.
2. Ramda without currying or composition:
	* Pros: Can be faster since it avoids the overhead of currying and composition.
	* Cons: Code can be more verbose and harder to understand for those unfamiliar with functional programming concepts.
3. Ramda with currying and composition:
	* Pros: Can be faster due to optimal function application, concise code.
	* Cons: May require a steeper learning curve due to the use of currying and composition.

**Library Explanation**

1. Lodash: A utility library providing a comprehensive set of functions for tasks like array manipulation, string manipulation, and more.
2. Ramda: A functional programming library that provides a set of higher-order functions (functions that take other functions as arguments) to manipulate data in a predictable and composable way.

**Special JS Feature or Syntax**

None mentioned.

**Alternatives**

Other alternatives for functional programming libraries in JavaScript include:

1. Underscore.js
2. Mnemonix
3. Lo-Dash

Note that each library has its own strengths and weaknesses, and the choice of which one to use depends on the specific requirements of your project.

**Benchmark Context**

The benchmark results show the performance differences between these three approaches for this specific task. The test is likely designed to demonstrate the trade-offs between readability, maintainability, and performance in functional programming.

Latest run results:

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

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

Browser/OS: Chrome 99 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Lodash	3425.9 Ops/sec
Ramda without relying on currying or composition	1934.6 Ops/sec
Ramda with currying and composition	1793.0 Ops/sec

Related benchmarks:

Ramda vs. Lodash updated (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: 3 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 27 days ago):