Benchmark: Ramda vs. Lodash (without chain)

Ramda vs. Lodash (without chain) (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 vs Lodash without chain

Created: 2 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>

AخA
 
<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;
}

​x
 
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)
  .pick('counter')
  .filter(isOdd)
  .map(square)
  .filter(lessThanThreeDigits)
  .value();

 
var result = _.chain(data)  .pick('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))));
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);
var result = R.pipe(
R.pluck('counter'),
R.filter(isOdd),
R.map(square),
R.filter(lessThanThreeDigits)
)(data);

Lodash without chain

var result = _.pick(
  _.filter(
   _.map(
      _.filter(data, lessThanThreeDigits),
      square),
    isOdd),
  'counter');

 
var result = _.pick(  _.filter(   _.map(      _.filter(data, lessThanThreeDigits),      square),    isOdd),  'counter');

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
Lodash
Ramda without relying on currying or composition
Ramda with currying and composition
Lodash without chain

Fastest: N/A

Slowest: N/A

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/103.0.0.0 Safari/537.36

Browser/OS: Chrome 103 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Lodash	544867.8 Ops/sec
Ramda without relying on currying or composition	1015.9 Ops/sec
Ramda with currying and composition	929.5 Ops/sec
Lodash without chain	6334.2 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 4 months ago):

Let's dive into the explanation of the provided benchmark.

Benchmark Purpose: The benchmark compares the performance of Lodash, Ramda, and native JavaScript on the same task. The task involves:

Creating an array of 10,000 objects with a "counter" property.
Filtering out odd items from the array.
Squaring the remaining even numbers.
Returning only the squared values that have less than two digits.

Options Compared:

Lodash without chain: This approach uses separate functions for each operation (_.filter, _.map, etc.) and does not use method chaining.
Ramda with currying and composition: Ramda is a functional programming library that provides a different way of expressing the same operations using currying (higher-order functions) and composition (combining smaller functions to create larger ones).
Ramda without relying on currying or composition: This approach uses Ramda's built-in functions, but not using currying or composition.
Native JavaScript: The benchmark also tests native JavaScript implementation of the same task.

Pros and Cons:

Lodash without chain: Pros:
- Easy to read and understand for developers familiar with Lodash.
- No performance impact due to method chaining. Cons:
- May be slower than other approaches due to multiple function calls.
Ramda with currying and composition: Pros:
- Often more concise and expressive than native JavaScript or Lodash without chain.
- Can lead to better performance due to optimized functions and caching. Cons:
- Steeper learning curve for developers unfamiliar with functional programming concepts.
- May be slower than other approaches if not implemented correctly.
Ramda without relying on currying or composition: Pros:
- Easy to understand for developers familiar with Ramda.
- May be faster than Lodash without chain due to optimized functions. Cons:
- May not be as concise or expressive as Ramda with currying and composition.
Native JavaScript: Pros:
- Often the fastest option due to direct implementation in native code. Cons:
- May require more boilerplate code, making it less readable.

Library Usage:

Lodash is a popular utility library for functional programming tasks. In this benchmark, Lodash provides _.range, _, .chain(), etc. functions that simplify the task.
Ramda is another functional programming library that provides R.filter, R.map, R.pipe functions to simplify the task.

Other Considerations:

Browser and Device: The benchmark results are specific to Chrome 103 on a Macintosh with Intel hardware, running macOS 10.15.7.
Performance Metrics: The benchmark measures the executions per second (ExecutionsPerSecond) value as the primary performance metric.

Alternative Approaches:

Other functional programming libraries like Underscore.js or Lo-Dash.
Native JavaScript implementations without using specific libraries like Ramda or Lodash.
Other programming paradigms, such as object-oriented programming or imperative programming, which may offer alternative solutions for this task.

Keep in mind that the choice of approach depends on the project requirements, performance constraints, and personal preference.

LLMs can make mistakes. Check important info.

Let's dive into the explanation of the provided benchmark.

**Benchmark Purpose:**
The benchmark compares the performance of Lodash, Ramda, and native JavaScript on the same task. The task involves:

1. Creating an array of 10,000 objects with a "counter" property.
2. Filtering out odd items from the array.
3. Squaring the remaining even numbers.
4. Returning only the squared values that have less than two digits.

**Options Compared:**

1. **Lodash without chain:** This approach uses separate functions for each operation (`_.filter`, `_.map`, etc.) and does not use method chaining.
2. **Ramda with currying and composition:** Ramda is a functional programming library that provides a different way of expressing the same operations using currying (higher-order functions) and composition (combining smaller functions to create larger ones).
3. **Ramda without relying on currying or composition:** This approach uses Ramda's built-in functions, but not using currying or composition.
4. **Native JavaScript:** The benchmark also tests native JavaScript implementation of the same task.

**Pros and Cons:**

1. **Lodash without chain:** Pros:
	* Easy to read and understand for developers familiar with Lodash.
	* No performance impact due to method chaining.
Cons:
	* May be slower than other approaches due to multiple function calls.
2. **Ramda with currying and composition:** Pros:
	* Often more concise and expressive than native JavaScript or Lodash without chain.
	* Can lead to better performance due to optimized functions and caching.
Cons:
	* Steeper learning curve for developers unfamiliar with functional programming concepts.
	* May be slower than other approaches if not implemented correctly.
3. **Ramda without relying on currying or composition:** Pros:
	* Easy to understand for developers familiar with Ramda.
	* May be faster than Lodash without chain due to optimized functions.
Cons:
	* May not be as concise or expressive as Ramda with currying and composition.
4. **Native JavaScript:** Pros:
	* Often the fastest option due to direct implementation in native code.
Cons:
	* May require more boilerplate code, making it less readable.

**Library Usage:**

1. Lodash is a popular utility library for functional programming tasks. In this benchmark, Lodash provides `_.range`, `_`, `.chain()`, etc. functions that simplify the task.
2. Ramda is another functional programming library that provides `R.filter`, `R.map`, `R.pipe` functions to simplify the task.

**Other Considerations:**

1. **Browser and Device:** The benchmark results are specific to Chrome 103 on a Macintosh with Intel hardware, running macOS 10.15.7.
2. **Performance Metrics:** The benchmark measures the executions per second (ExecutionsPerSecond) value as the primary performance metric.

**Alternative Approaches:**

1. Other functional programming libraries like Underscore.js or Lo-Dash.
2. Native JavaScript implementations without using specific libraries like Ramda or Lodash.
3. Other programming paradigms, such as object-oriented programming or imperative programming, which may offer alternative solutions for this task.

Keep in mind that the choice of approach depends on the project requirements, performance constraints, and personal preference.

Related benchmarks: