Benchmark: Cilq Ramda vs. Lodash 1

Cilq Ramda vs. Lodash 1 (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/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

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON data to understand what is being tested in this JavaScript microbenchmark.

**Benchmark Definition**

The benchmark compares the performance of three different approaches:

1. **Lodash**: A popular JavaScript utility library that provides a lot of pre-built functions for tasks like array manipulation, string manipulation, and more.
2. **Ramda without currying or composition**: Ramda is another popular functional programming library for JavaScript. In this case, we're using it in a way that doesn't rely on its currying (passing functions as arguments) or composition (chaining multiple functions together).
3. **Ramda with currying and composition**: Similar to the previous approach, but this time we're using Ramda's full capabilities, including currying and composition.

**What is being tested?**

In each test case, the benchmark is testing the performance of pulling the "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. The tests are designed to be identical across all three approaches.

**Options compared**

The options being compared are:

* **Lodash**: Uses Lodash's `chain()` function to create a pipeline of functions, which is a concise way to perform multiple operations on an array.
* **Ramda without currying or composition**: Uses Ramda's individual functions (`filter()`, `map()`, etc.) to perform the same operations as Lodash, but in a more explicit and verbose way.
* **Ramda with currying and composition**: Uses Ramda's full capabilities, including currying (passing functions as arguments) and composition (chaining multiple functions together), to achieve the same result.

**Pros and cons**

Here are some pros and cons of each approach:

* **Lodash**: Pros: concise, easy to read, and maintain. Cons: may be less efficient than other approaches due to its pipeline nature.
* **Ramda without currying or composition**: Pros: explicit, easy to understand, and potentially more efficient. Cons: verbose, harder to read.
* **Ramda with currying and composition**: Pros: highly expressive, can achieve complex results easily. Cons: may be less readable, and can lead to performance issues if not optimized correctly.

**Library usage**

In the benchmark definition JSON, we see that:

* Lodash is used in the `chain()` function.
* Ramda is used directly in its individual functions (`filter()`, `map()`, etc.).

**Special JavaScript features or syntax**

There are no special JavaScript features or syntax mentioned in this benchmark. All tests use standard JavaScript syntax and libraries.

Now, let's discuss some alternative approaches:

1. **Vanilla JavaScript**: You could achieve the same result using only vanilla JavaScript functions (e.g., `forEach()`, `map()`, `filter()`).
2. **Other functional programming libraries**: Libraries like Lo-Dash or Underscore.js provide similar functionality to Ramda.
3. **TypeScript**: If you're using TypeScript, you might consider using its type system and interfaces to optimize the benchmark for better performance.

Keep in mind that this is just one possible interpretation of the benchmark data. Different users may have different opinions on the best approach based on their specific use cases and preferences.

Latest run results:

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

User agent: Mozilla/5.0 (iPad; CPU OS 12_1_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.0 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 12 on iOS 12.1.4

View result in a separate tab

Test name	Executions per second
Lodash	788.4 Ops/sec
Ramda without relying on currying or composition	184.5 Ops/sec
Ramda with currying and composition	179.3 Ops/sec

Related benchmarks:

Cilq Ramda vs. Lodash 1 (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 26 days ago):