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

Autogenerated LLM Summary (model gemma2:9b, generated one month ago):

LLMs can make mistakes. Check important info.

This benchmark compares the performance of three different approaches to processing an array of objects:

* **Lodash:** Uses the Lodash library's `chain` method for functional programming style operations. 
* **Ramda (without currying/composition):** Implements the same logic using Ramda functions without explicitly leveraging its currying and composition capabilities.
* **Ramda (with currying/composition):**  Uses Ramda's `pipe` function to chain together functions in a more concise and potentially efficient manner.

**Here's a breakdown of each approach:**

1. **Lodash:** 
    - Leverages the familiar `.map`, `.filter`, and `.value()` methods for functional style programming.
    - Relatively easy to understand and use for developers already familiar with Lodash.
    - Performance can be affected by the chaining overhead.

2. **Ramda (without currying/composition):**
    -  Applies Ramda functions directly, mimicking the procedural style.
    - May result in less readable code compared to using `pipe`.

3. **Ramda (with currying/composition):**
    - Utilizes `pipe` for a more functional and potentially efficient approach by composing functions together.
    - Can lead to more concise and expressive code.

* **Pros:** Ramda's currying and composition can be powerful for creating reusable functions and improving performance in certain cases.
* **Cons:**  It can introduce a learning curve for developers unfamiliar with functional programming paradigms.

**Other Considerations:**

* **Data Size:** The benchmark uses an array of 10,000 objects. Real-world scenarios might involve vastly different data sizes, impacting performance differences between the approaches.
* **Hardware/Software:**  The benchmark results can be influenced by factors like the user's hardware (CPU speed, RAM), operating system, and JavaScript engine (V8 in Chrome, SpiderMonkey in Firefox).

**Alternatives:**

* **Native JavaScript:** 
    - You could implement the same logic using native JavaScript functions (`forEach`, `filter`, `map`, etc.). This might be a good baseline for comparison.

* **Other Libraries:**  Explore other functional programming libraries like Immutable.js or Underscore.js, which offer different strengths and tradeoffs.

**Remember**: Benchmark results are highly context-dependent. 
The "best" approach depends on the specific task, data size, developer familiarity, and desired code style.

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

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 gemma2:9b, generated one month ago):