Benchmark: Ramda vs. Lodash 2

Ramda vs. Lodash 2 (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: 6 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.4/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

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:60.0) Gecko/20100101 Firefox/60.0

Browser/OS: Firefox 60 on Windows 7

View result in a separate tab

Test name	Executions per second
Lodash	500.3 Ops/sec
Ramda without relying on currying or composition	254.8 Ops/sec
Ramda with currying and composition	239.4 Ops/sec

Autogenerated LLM Summary (model llama3.1:latest, generated 2 months ago):

LLMs can make mistakes. Check important info.

Let's dive into the benchmark results.

**What is being tested?**

The test case is evaluating the performance of three different approaches to process an array of objects:

1. Pulling the `counter` property from each item, filtering out odd items, squaring them, and returning those squared values that have less than two digits.
2. The task involves a series of operations on the data:
	* Filtering out odd numbers
	* Squaring the numbers
	* Filtering out numbers with more than two digits

**Options being compared**

The benchmark compares three different implementations:

1. **Lodash**: Using Lodash's `chain` method to create a chainable sequence of functions, which allows for easier composition and reuse.
2. **Ramda without relying on currying or composition**: Using Ramda's functional programming utilities (e.g., `filter`, `map`) without relying on its currying and composition features.
3. **Ramda with currying and composition**: Leveraging Ramda's currying and composition features to write a more concise and expressive implementation.

**Pros and cons of each approach**

1. **Lodash**:
	* Pros: Easy to read and understand, especially for developers familiar with Lodash's API.
	* Cons: May be less efficient than functional programming approaches due to the overhead of chainable functions.
2. **Ramda without relying on currying or composition**:
	* Pros: Still uses functional programming utilities, making it more efficient than Lodash.
	* Cons: May be less concise and readable than the other two options.
3. **Ramda with currying and composition**:
	* Pros: Most expressive and concise implementation, leveraging Ramda's strengths.
	* Cons: May require a deeper understanding of functional programming concepts.

**Other considerations**

The test case uses the following libraries:

1. **Lodash**: A popular JavaScript utility library for tasks such as data manipulation, functional programming, and more.
2. **Ramda**: A functional programming library for JavaScript that provides utilities like `filter`, `map`, and `pipe`.

In terms of special JS features or syntax used in this test case, there is none mentioned.

**Other alternatives**

If you want to implement this benchmark without using Lodash or Ramda, you could use vanilla JavaScript with its built-in `Array.prototype` methods (e.g., `filter`, `map`). However, the resulting code might be less efficient and less readable than the implementations shown here.

Keep in mind that the performance results will vary depending on the specific browser, device platform, and operating system used.

Related benchmarks:

Ramda vs. Lodash 2 (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: 6 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.1:latest, generated 2 months ago):