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

JS native vs js native loop vs Ramda vs. Lodash 4 (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: 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>

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

Autogenerated LLM Summary (model llama3.2:3b, generated 25 days ago):

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided JSON represents a JavaScript microbenchmark that compares the performance of different approaches for filtering, squaring, and transforming data in an array. The benchmark is run on Firefox 101 browser on a Mac OS X 10.15 machine.

**Approaches Compared**

1. **JS Native Loop**: A traditional loop-based approach using a for loop to iterate through the array.
2. **Lodash**: Using Lodash's `map` function to transform and filter data in an array.
3. **Ramda Without Currying**: Using Ramda's `filter` and `map` functions without currying (i.e., not passing functions as arguments).
4. **Ramda With Currying**: Using Ramda's curried version of `filter` and `map` functions.
5. **Ramda Transducer**: Using Ramda's transducer function to transform and filter data in an array.
6. **Ramda Without Composition**: Similar to the above, but without using composition (i.e., not chaining multiple functions together).
7. **Ramda With Transducer**: Using Ramda's transducer function.

**Performance Comparison**

The benchmark results show that:

* The JS Native Loop approach is the fastest, with an average of 159 executions per second.
* Lodash is relatively fast, with an average of 50 executions per second.
* The Ramda approaches (without currying and without transducer) are significantly slower than the others, with averages ranging from 45 to 50 executions per second.
* The Ramda Transducer approach is faster than the non-transducer approaches, but still slower than the JS Native Loop.

**Interpretation**

The results suggest that the JS Native Loop approach is the most efficient due to its lack of overhead from function calls and object creation. Lodash's `map` function is relatively fast, but may incur some additional overhead due to its higher-level abstractions. The Ramda approaches, while elegant and expressive, are slower due to their functional programming style and use of immutable data structures.

Overall, the benchmark highlights the importance of choosing the right approach for your specific use case, considering factors such as performance, readability, and maintainability.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:101.0) Gecko/20100101 Firefox/101.0

Browser/OS: Firefox 101 on Mac OS X 10.15

View result in a separate tab

Test name	Executions per second
JS native	166.6 Ops/sec
Ramda with transducer	45.7 Ops/sec
Ramda with transducer (no prop)	168.4 Ops/sec
Ramda with currying and composition	50.4 Ops/sec
Ramda without relying on currying or composition	50.5 Ops/sec
Ramda with currying and composition (no pluck)	181.2 Ops/sec
Lodash	159.0 Ops/sec
js native loop	241.2 Ops/sec

Related benchmarks:

JS native vs js native loop vs Ramda vs. Lodash 4 (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: 2 years ago by: Guest

Jump to the latest 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

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 25 days ago):