Benchmark: Ramda (/w transducer no pluck) vs. Lodash

Ramda (/w transducer no pluck) vs. Lodash (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: JS native vs Ramda with transducer vs Ramda with currying and composition vs Ramda without relying on currying or composition vs Ramda with currying and composition (no pluck) vs Lodash

Created: 3 years ago by: Guest

Jump to the latest result

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.28.0/ramda.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.15/lodash.min.js"></script>

AخA
 
<script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.28.0/ramda.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.15/lodash.min.js"></script>

Script Preparation code:

var data = _.range(100000).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(100000).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:

JS native

var result = data
  .map(({counter}) => counter)
  .filter(isOdd)
  .map(square)
  .filter(lessThanThreeDigits)

 
var result = data  .map(({counter}) => counter)  .filter(isOdd)  .map(square)  .filter(lessThanThreeDigits)

Ramda with transducer

var transducer = R.compose (
  R.map(R.prop('counter')),
  R.filter(isOdd),
  R.map(square),
  R.filter(lessThanThreeDigits),
);

var result = R.transduce (
  transducer,
  (acc, val) => {
    acc.push(val);
    return acc;
  },
  [],
  data,
);

 
var transducer = R.compose (  R.map(R.prop('counter')),  R.filter(isOdd),  R.map(square),  R.filter(lessThanThreeDigits),);​var result = R.transduce (  transducer,  (acc, val) => {    acc.push(val);    return acc;  },  [],  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);
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 (no pluck)
var result = R.pipe( R.map (({counter}) => counter), R.filter(isOdd), R.map(square), R.filter(lessThanThreeDigits) )(data);
var result = R.pipe(
R.map (({counter}) => counter),
R.filter(isOdd),
R.map(square),
R.filter(lessThanThreeDigits)
)(data);

Lodash

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

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

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
JS native
Ramda with transducer
Ramda with currying and composition
Ramda without relying on currying or composition
Ramda with currying and composition (no pluck)
Lodash

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 15_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.4 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 15 on iOS 15.4

View result in a separate tab

Test name	Executions per second
JS native	167.3 Ops/sec
Ramda with transducer	130.6 Ops/sec
Ramda with currying and composition	112.8 Ops/sec
Ramda without relying on currying or composition	97.8 Ops/sec
Ramda with currying and composition (no pluck)	144.6 Ops/sec
Lodash	154.5 Ops/sec

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

Let's break down the benchmark and explain what's being tested.

Benchmark Overview

The benchmark compares the performance of four JavaScript libraries: Ramda, Lodash, and two styles of native JavaScript (JS native). The task is to process an array of objects, filtering out odd numbers, squaring them, and returning values with less than three digits.

Library and Syntax Explanation

Ramda: A functional programming library for JavaScript. It provides a concise way to perform operations on arrays and objects using a transducer-based syntax.
Lodash: A utility library that provides a wide range of functions for tasks such as string manipulation, array manipulation, and more.

JS Native (JavaScript)

This option uses only native JavaScript features and syntax, without any external libraries.

Options Compared

The benchmark compares the performance of:

Ramda with Transducer: Uses Ramda's transducer-based syntax to process the data.
Ramda with Currying and Composition: Uses Ramda's curried functions and composition feature to process the data.
Ramda without Relying on Currying or Composition: A variation of the previous option that uses a different approach, but still leverages Ramda's syntax.
Lodash: Uses Lodash's pipeline-based syntax to process the data.

Pros and Cons

JS Native (JavaScript):
- Pros: No external dependencies, native performance.
- Cons: Requires manual looping and conditionals, can be less efficient due to overhead of JavaScript engine.
Ramda with Transducer:
- Pros: Compact and expressive syntax, easy to read and maintain.
- Cons: May have higher overhead due to the transducer mechanism.
Ramda with Currying and Composition:
- Pros: More concise than traditional functional programming, easier to chain operations.
- Cons: Can be less readable for those unfamiliar with curried functions and composition.
Lodash:
- Pros: Wide range of utility functions, easy to use and understand.
- Cons: May have higher overhead due to the pipeline syntax.

Performance Results

The benchmark results show that Ramda's transducer-based syntax (option 1) is the fastest, followed closely by Lodash. The native JavaScript option (option 3) is slower, while the two Ramda options with currying and composition are significantly slower than the first one.

Overall, the benchmark suggests that Ramda's transducer-based syntax can provide a good balance between performance and readability, making it a popular choice among developers. Lodash, on the other hand, excels at providing a wide range of utility functions, but may have higher overhead due to its pipeline syntax.

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what's being tested.

**Benchmark Overview**

**Library and Syntax Explanation**

1. **Ramda**: A functional programming library for JavaScript. It provides a concise way to perform operations on arrays and objects using a transducer-based syntax.
2. **Lodash**: A utility library that provides a wide range of functions for tasks such as string manipulation, array manipulation, and more.

**JS Native (JavaScript)**

This option uses only native JavaScript features and syntax, without any external libraries.

**Options Compared**

The benchmark compares the performance of:

1. **Ramda with Transducer**: Uses Ramda's transducer-based syntax to process the data.
2. **Ramda with Currying and Composition**: Uses Ramda's curried functions and composition feature to process the data.
3. **Ramda without Relying on Currying or Composition**: A variation of the previous option that uses a different approach, but still leverages Ramda's syntax.
4. **Lodash**: Uses Lodash's pipeline-based syntax to process the data.

**Pros and Cons**

* **JS Native (JavaScript)**:
	+ Pros: No external dependencies, native performance.
	+ Cons: Requires manual looping and conditionals, can be less efficient due to overhead of JavaScript engine.
* **Ramda with Transducer**:
	+ Pros: Compact and expressive syntax, easy to read and maintain.
	+ Cons: May have higher overhead due to the transducer mechanism.
* **Ramda with Currying and Composition**:
	+ Pros: More concise than traditional functional programming, easier to chain operations.
	+ Cons: Can be less readable for those unfamiliar with curried functions and composition.
* **Lodash**:
	+ Pros: Wide range of utility functions, easy to use and understand.
	+ Cons: May have higher overhead due to the pipeline syntax.

**Performance Results**

Related benchmarks: