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>

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

Tests:

Lodash
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))));
Ramda with currying and composition
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

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: 5 hours ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36

Browser/OS: Chrome 131 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Lodash	756591.1 Ops/sec
Ramda without relying on currying or composition	1108.8 Ops/sec
Ramda with currying and composition	1058.0 Ops/sec

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

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:

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

Lodash

Ramda without relying on currying or composition

Ramda with currying and composition

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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