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

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

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64; rv:106.0) Gecko/20100101 Firefox/106.0

Browser/OS: Firefox 106 on Linux

View result in a separate tab

Test name	Executions per second
JS native	94.9 Ops/sec
Ramda with transducer	29.0 Ops/sec
Ramda with transducer (no prop)	85.5 Ops/sec
Ramda with currying and composition	28.8 Ops/sec
Ramda without relying on currying or composition	28.4 Ops/sec
Ramda with currying and composition (no pluck)	92.2 Ops/sec
Lodash	90.0 Ops/sec

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

Let's dive into the world of JavaScript microbenchmarks.

Benchmark Overview

The provided benchmark compares the performance of three approaches:

Native JavaScript (JS native)
Ramda with transducer
Ramda without relying on currying or composition
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:

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

Pros and Cons

JS native:
- Pros: Easy to understand, no dependencies required.
- Cons: May be slower due to function overhead.
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.
Ramda with transducer:
- Pros: Optimized for performance, concise and expressive code.
- Cons: Steeper learning curve due to new concepts (transducers).
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:

JS native: 94.90333557128906
Ramda with currying and composition (no pluck): 92.16983032226562
Lodash: 89.96233367919922
Ramda with transducer (no prop): 85.46060180664062
Ramda with transducer: 29.048656463623047
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.

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: