Benchmark: JS native vs js native loop vs Ramda vs. Lodash

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

Created: 2 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 transducer (no prop)
var transducer = R.compose ( R.map(({counter}) => 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(({counter}) => 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();

js native loops

let result = [];
for (let i=0; i<data.length; i++) {
  const { counter } = data[i];
  if (isOdd (counter)) {
    console.log ('t', counter);
    let squared = square (counter);
    if (lessThanThreeDigits (squared)) {
      result.push (squared);
    }
  }
}

 
let result = [];for (let i=0; i<data.length; i++) {  const { counter } = data[i];  if (isOdd (counter)) {    console.log ('t', counter);    let squared = square (counter);    if (lessThanThreeDigits (squared)) {      result.push (squared);    }  }}

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

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0

Browser/OS: Firefox 121 on Windows

View result in a separate tab

Test name	Executions per second
JS native	187.7 Ops/sec
Ramda with transducer	65.4 Ops/sec
Ramda with transducer (no prop)	161.5 Ops/sec
Ramda with currying and composition	73.5 Ops/sec
Ramda without relying on currying or composition	99.0 Ops/sec
Ramda with currying and composition (no pluck)	186.3 Ops/sec
Lodash	174.7 Ops/sec
js native loops	3.9 Ops/sec

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

Let's break down what is being tested in this benchmark.

Benchmark Definition: The benchmark compares the performance of four different approaches to achieve the same result:

Native JavaScript: Using traditional JavaScript syntax to filter, map, and transform an array.
Ramda with Transducer: Using Ramda's transducer function to chain together filters, maps, and reductions.
Ramda with Curry and Composition: Using Ramda's curried functions to compose multiple operations together.
Lodash: Using Lodash's filter and map methods to transform an array.

Common operations:

Filter out elements that don't meet a condition (e.g., even numbers).
Map each element to its square.
Keep only the transformed elements.

The benchmark measures the execution speed of each approach, reported as executions per second (EPs/s), which is calculated by dividing the number of iterations completed in one second by the duration of the test.

Key observations:

Native JavaScript loops are the slowest, indicating that this approach may not be optimal for performance-critical code.
Ramda's transducer and curried functions perform similarly well, suggesting that these approaches can take advantage of functional programming principles to achieve good performance.
Lodash is slower than both Ramda-based approaches, possibly due to its more imperative nature.

Overall, this benchmark highlights the importance of choosing the right library or approach for a specific problem. In this case, Ramda's functional programming paradigm and curried functions seem to provide a good balance between performance and expressiveness.

LLMs can make mistakes. Check important info.

Let's break down what is being tested in this benchmark.

**Benchmark Definition:**
The benchmark compares the performance of four different approaches to achieve the same result:

1. **Native JavaScript**: Using traditional JavaScript syntax to filter, map, and transform an array.
2. **Ramda with Transducer**: Using Ramda's transducer function to chain together filters, maps, and reductions.
3. **Ramda with Curry and Composition**: Using Ramda's curried functions to compose multiple operations together.
4. **Lodash**: Using Lodash's `filter` and `map` methods to transform an array.

**Common operations:**

* Filter out elements that don't meet a condition (e.g., even numbers).
* Map each element to its square.
* Keep only the transformed elements.

**Key observations:**

* Native JavaScript loops are the slowest, indicating that this approach may not be optimal for performance-critical code.
* Ramda's transducer and curried functions perform similarly well, suggesting that these approaches can take advantage of functional programming principles to achieve good performance.
* Lodash is slower than both Ramda-based approaches, possibly due to its more imperative nature.

Related benchmarks: