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

JS native vs js native loop vs 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: 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 loop

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>

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

Tests:

JS native
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, );
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, );
Ramda with currying and composition
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))));
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);
Lodash
var result = _.chain(data) .map('counter') .filter(isOdd) .map(square) .filter(lessThanThreeDigits) .value();
js native loop
let result = []; for (let i=0; i<data.length; i++) { const { counter } = data[i]; if (isOdd (counter)) { let squared = square (counter); if (lessThanThreeDigits (squared)) { result.push (squared); } } }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

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 loop

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**What is being tested?**

The benchmark compares the performance of four different approaches to filter an array of numbers and push the squared value to an output array:

1. **JS Native Loop**: A simple loop that iterates through the input array, checks if the number is odd, squares it, and pushes the result to the output array.
2. **Lodash**: The `filter` method from Lodash is used to create a new array with only the odd numbers, which are then squared and pushed to an output array.
3. **Ramda with Currying and Composition**: Ramda's `filter` function is used with curried and composited logic to achieve the same result as Lodash.
4. **Ramda with Transducer**: Another approach using Ramda's transducer functionality to filter and map the data.

**Key insights**

* The JS Native Loop appears to be the fastest, likely due to its simplicity and direct access to the input array.
* Lodash is relatively fast, thanks to its optimized `filter` method.
* Ramda's approaches are slower than Lodash and the native loop, possibly due to the overhead of functional programming concepts like currying and transducers.

**Comparison**

Here's a rough ranking of the approaches by their performance:

1. JS Native Loop (~50-60% faster than the next best)
2. Lodash
3. Ramda with Transducer
4. Ramda with Currying and Composition

Keep in mind that these results may vary depending on the specific use case, input data, and browser/OS configurations.

**Takeaways**

1. When dealing with simple filtering tasks, a native loop can be an efficient solution.
2. Lodash's `filter` method is a solid choice when you need to perform multiple operations on an array.
3. Ramda's functional programming concepts require more overhead, but can still offer benefits like immutability and composability.

I hope this analysis helps!

Related benchmarks: