Benchmark: Ramda vs. Lodash 2021

Ramda vs. Lodash 2021 (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: 2 years ago by: Guest

Jump to the latest result

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.27.1/ramda.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.21/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

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON to understand what is being tested.

**Benchmark Definition**

The benchmark compares the performance of three different approaches:

1. **Lodash**: Uses the `_.chain()` function to chain multiple functions together, which allows for more readable code but potentially slower execution due to the overhead of creating a new scope.
2. **Ramda without currying or composition**: Uses individual functions (`R.filter()`, `R.map()`, etc.) without chaining them together. This approach can be faster since it avoids the overhead of creating a new scope.
3. **Ramda with currying and composition**: Uses Ramda's functional programming style, where functions are composed using `R.pipe()` to create a pipeline of operations. This approach is often more concise but may incur additional overhead due to the creation of function calls.

**Pros and Cons**

* **Lodash (`.chain()`)**:
	+ Pros: More readable code, easier to understand the intent.
	+ Cons: Potentially slower execution due to scope overhead.
* **Ramda without currying or composition**:
	+ Pros: Faster execution, avoids scope overhead.
	+ Cons: Code may look less concise and less readable.
* **Ramda with currying and composition**:
	+ Pros: More concise code, can be easier to read and understand the intent.
	+ Cons: May incur additional overhead due to function call creation.

**Library and Purpose**

* **Lodash**: A popular utility library for JavaScript that provides a wide range of functions for tasks such as string manipulation, array processing, and more. The `.chain()` function is used to chain multiple functions together, making it easier to write readable code.
* **Ramda**: A functional programming library for JavaScript that provides a set of higher-order functions (functions that take other functions as arguments) for tasks such as data transformation, filtering, and mapping.

**Special JS Features or Syntax**

None mentioned in the provided JSON.

**Other Alternatives**

* For an alternative approach to Ramda's currying and composition, one could use vanilla JavaScript functions like `map()`, `filter()`, and `reduce()`.
* Another option for a library similar to Lodash is **Underscore.js**, which provides many of the same utility functions.

**Benchmarking Considerations**

When benchmarking performance differences between these approaches, it's essential to consider factors such as:

* Code readability vs. execution speed
* Overhead of function call creation and scope management
* Optimizations for specific use cases or datasets

Keep in mind that this benchmark is comparing different coding styles and libraries, so the results may not be directly applicable to real-world use cases.

By understanding these factors and considering alternative approaches, developers can make informed decisions about which code style and library to use depending on their specific needs.

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36

Browser/OS: Chrome 114 on Linux

View result in a separate tab

Test name	Executions per second
Lodash	642466.8 Ops/sec
Ramda without relying on currying or composition	737.7 Ops/sec
Ramda with currying and composition	710.3 Ops/sec

Related benchmarks:

Ramda vs. Lodash 2021 (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: 2 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 25 days ago):