Benchmark: Ramda vs. Lodash

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: Lodash vs Ramda without relying on currying or composition vs Ramda with currying and composition

Created: 6 years ago by: Guest

Jump to the latest result

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.25.0/ramda.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js"></script>

AخA
 
<script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.25.0/ramda.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js"></script>

Script Preparation code:

var data = _.range(10000).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(10000).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:

Lodash

var result = _.chain(data)
  .pick('counter')
  .filter(isOdd)
  .map(square)
  .filter(lessThanThreeDigits)
  .value();

 
var result = _.chain(data)  .pick('counter')  .filter(isOdd)  .map(square)  .filter(lessThanThreeDigits)  .value();

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

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
Lodash
Ramda without relying on currying or composition
Ramda with currying and composition

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 22 days ago)

User agent: Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Mobile Safari/537.36

Browser/OS: Chrome Mobile 133 on Android

View result in a separate tab

Test name	Executions per second
Lodash	757823.2 Ops/sec
Ramda without relying on currying or composition	1007.6 Ops/sec
Ramda with currying and composition	938.7 Ops/sec

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

I'll break down the provided benchmark and explain what's being tested, compared, and the pros/cons of each approach.

Benchmark Overview

The benchmark compares the performance of Lodash, Ramda (in two different styles), and "native" JavaScript on the same task. The task involves:

Creating an array of 10,000 objects with a counter property.
Filtering out odd items from the array using the isOdd function.
Squaring the remaining even numbers using the square function.
Returning only the squared values that have less than two digits.

Library and Purpose

Lodash: Lodash is a popular JavaScript utility library that provides a wide range of functions for tasks like array manipulation, string manipulation, and more. The chain, filter, map, and pick functions are used in the benchmark to perform the specified task.
Ramda: Ramda is another functional programming library for JavaScript. It provides a different set of functions for array manipulation, object manipulation, and more. The benchmark tests two styles of using Ramda:
- Without relying on currying or composition: This style uses the filter, map, and pluck functions directly to perform the task.
- With currying and composition: This style uses the pipe function to compose multiple functions together to achieve the desired result.

Native JavaScript

The benchmark also includes a native JavaScript implementation of the task, which is used as a baseline for comparison. This approach uses simple array methods like filter, map, and forEach.

Comparison and Pros/Cons

Lodash: The Lodash implementation is likely to be the fastest due to its optimized functions and caching mechanisms. However, it may also be the most verbose, as it requires a more explicit pipeline of functions.
Ramda Without Currying: This style is less efficient than the other two because it involves more function calls and creates temporary arrays. It's still a good option for developers who prefer a more functional programming style but want to avoid currying and composition.
Ramda With Currying: This style is likely to be faster than the Ramda Without Currying approach because it reduces the number of function calls and uses a single, optimized pipeline. However, it may require more upfront setup and understanding of Ramda's API.
Native JavaScript: The native JavaScript implementation is likely to be slower due to its lack of optimization and caching mechanisms. However, it provides a good baseline for comparison and can help developers understand the performance characteristics of their own code.

Other Considerations

Memory Usage: All three implementations have different memory usage profiles, with Lodash and Ramda potentially using more memory than native JavaScript due to their caching mechanisms.
Code Readability: The readability of each implementation varies, with native JavaScript being likely the most readable but also potentially slower. Lodash and Ramda require more explicit pipeline functions, which can make the code harder to read for some developers.

Alternatives

Other alternatives that could be tested in a benchmark include:

Other functional programming libraries like Underscore.js or Lisk
Closures-based implementations of the task
Using map and reduce instead of filter and forEach
Using WebAssembly (WASM) to execute the code for better performance.

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark and explain what's being tested, compared, and the pros/cons of each approach.

**Benchmark Overview**

The benchmark compares the performance of Lodash, Ramda (in two different styles), and "native" JavaScript on the same task. The task involves:

1. Creating an array of 10,000 objects with a `counter` property.
2. Filtering out odd items from the array using the `isOdd` function.
3. Squaring the remaining even numbers using the `square` function.
4. Returning only the squared values that have less than two digits.

**Library and Purpose**

1. **Lodash**: Lodash is a popular JavaScript utility library that provides a wide range of functions for tasks like array manipulation, string manipulation, and more. The `chain`, `filter`, `map`, and `pick` functions are used in the benchmark to perform the specified task.
2. **Ramda**: Ramda is another functional programming library for JavaScript. It provides a different set of functions for array manipulation, object manipulation, and more. The benchmark tests two styles of using Ramda:
	* **Without relying on currying or composition**: This style uses the `filter`, `map`, and `pluck` functions directly to perform the task.
	* **With currying and composition**: This style uses the `pipe` function to compose multiple functions together to achieve the desired result.

**Native JavaScript**

The benchmark also includes a native JavaScript implementation of the task, which is used as a baseline for comparison. This approach uses simple array methods like `filter`, `map`, and `forEach`.

**Comparison and Pros/Cons**

1. **Lodash**: The Lodash implementation is likely to be the fastest due to its optimized functions and caching mechanisms. However, it may also be the most verbose, as it requires a more explicit pipeline of functions.
2. **Ramda Without Currying**: This style is less efficient than the other two because it involves more function calls and creates temporary arrays. It's still a good option for developers who prefer a more functional programming style but want to avoid currying and composition.
3. **Ramda With Currying**: This style is likely to be faster than the Ramda Without Currying approach because it reduces the number of function calls and uses a single, optimized pipeline. However, it may require more upfront setup and understanding of Ramda's API.
4. **Native JavaScript**: The native JavaScript implementation is likely to be slower due to its lack of optimization and caching mechanisms. However, it provides a good baseline for comparison and can help developers understand the performance characteristics of their own code.

**Other Considerations**

* **Memory Usage**: All three implementations have different memory usage profiles, with Lodash and Ramda potentially using more memory than native JavaScript due to their caching mechanisms.
* **Code Readability**: The readability of each implementation varies, with native JavaScript being likely the most readable but also potentially slower. Lodash and Ramda require more explicit pipeline functions, which can make the code harder to read for some developers.

**Alternatives**

Other alternatives that could be tested in a benchmark include:

* Other functional programming libraries like Underscore.js or Lisk
* Closures-based implementations of the task
* Using `map` and `reduce` instead of `filter` and `forEach`
* Using WebAssembly (WASM) to execute the code for better performance.

Related benchmarks: