Benchmark: JS native vs Ramda vs. Lodash

JS native 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

Created: 4 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();

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

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.

**Benchmark Overview**

The provided benchmark compares the performance of three approaches:

1. Native JavaScript (JS native)
2. Ramda with transducer
3. Ramda without relying on currying or composition
4. Lodash

All tests perform the following operations on an array of objects:

* Extract the "counter" property from each object
* Filter out odd numbers
* Square the remaining numbers
* Filter out numbers with less than 2 digits

**Options Compared**

The benchmark compares four different approaches:

1. **JS native**: Performs the operations using standard JavaScript functions.
2. **Ramda without currying or composition**: Uses Ramda's `map` and `filter` functions to perform the operations, but without relying on currying or composition.
3. **Ramda with transducer**: Uses Ramda's transducer API to chain together multiple functions and apply them to the data.
4. **Lodash**: Uses Lodash's `chain` function to pipe together multiple functions and apply them to the data.

**Pros and Cons**

1. **JS native**:
	* Pros: Easy to understand, no dependencies required.
	* Cons: May be slower due to function overhead.
2. **Ramda without currying or composition**:
	* Pros: Still uses Ramda's optimized functions, easy to understand.
	* Cons: May not be as efficient as the transducer API.
3. **Ramda with transducer**:
	* Pros: Optimized for performance, concise and expressive code.
	* Cons: Steeper learning curve due to new concepts (transducers).
4. **Lodash**:
	* Pros: Provides a convenient way to chain functions together, easy to understand.
	* Cons: May be slower than native JavaScript or Ramda's transducer API.

**Benchmark Results**

The benchmark results show the average number of executions per second for each test:

1. JS native: 94.90333557128906
2. Ramda with currying and composition (no pluck): 92.16983032226562
3. Lodash: 89.96233367919922
4. Ramda with transducer (no prop): 85.46060180664062
5. Ramda with transducer: 29.048656463623047
6. Ramda without relying on currying or composition: 28.411849975585938

The results suggest that:

* JS native is the fastest approach.
* Ramda's transducer API is the most efficient way to chain functions together, outperforming Ramda without currying and Lodash.
* Ramda without currying and composition is still a good option, but slightly slower than the transducer API.

Keep in mind that these results are specific to this benchmark and may not generalize to other use cases.

Related benchmarks: