Benchmark: Ramda vs. Lodash (fix)

Ramda vs. Lodash (fix) (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: 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 gemma2:9b, generated one month ago):

LLMs can make mistakes. Check important info.

This benchmark tests the performance of three different approaches to processing an array of objects in JavaScript:

* **Lodash:**  A popular library known for its utility functions, including `chain`, `map`, `filter`, and `value`. 
* **Ramda without currying or composition:** This approach uses Ramda's functions (`filter`, `map`, `pluck`) but avoids using its advanced features like currying and composition.  This is a more straightforward style of writing the code.

* **Ramda with currying and composition:**  This approach leverages Ramda's powerful concepts of currying (breaking down functions into smaller, reusable parts) and function composition (chaining functions together). This often leads to more concise and expressive code.

**Let's break down what the code is doing:**

The benchmark simulates a common data processing task:

1. **Data Generation:** It creates an array of 10,000 objects, each containing a `counter` property representing a number from 0 to 9,999.
2. **Filtering and Transformation:**  Each approach then performs these operations on the array:

* Extracts the `counter` value from each object (`R.pluck('counter')`, `_.map('counter')`).
   * Filters out odd numbers (`R.filter(isOdd)`, Lodash's `filter` with `isOdd` as the predicate).
   * Squares the remaining even numbers (`R.map(square)`).
   * Filters the squared values to keep only those with less than three digits (`R.filter(lessThanThreeDigits)`).

3. **Output:** The final result is a new array containing the squared values that meet the criteria.

**Pros and Cons:**

* **Lodash:** 
    * **Pros:** Widely used, easy to learn, provides many other useful functions.
    * **Cons:** Can be verbose compared to Ramda's curried style, might not be as performant for complex operations.

* **Ramda (without currying/composition):**
    * **Pros:**  More readable than Lodash in this specific case, avoids the overhead of currying and composition. 
    * **Cons:** Less concise than Ramda's full potential, might not be as performant as its optimized form with currying and composition.

* **Ramda (with currying/composition):**
    * **Pros:** Most concise and potentially most performant due to optimized function execution. 
    * **Cons:** Steeper learning curve for beginners, requires understanding of functional programming concepts.

**Alternatives:**

Other libraries like Immutable.js or plain JavaScript with built-in array methods could also be used. The choice depends on factors like code readability, performance requirements, and team familiarity.

Latest run results:

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

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

Browser/OS: Chrome 67 on Linux

View result in a separate tab

Test name	Executions per second
Lodash	1042.8 Ops/sec
Ramda without relying on currying or composition	637.5 Ops/sec
Ramda with currying and composition	604.0 Ops/sec

Related benchmarks:

Ramda vs. Lodash (fix) (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: 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 gemma2:9b, generated one month ago):