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.4/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) .map('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 27 days ago):

LLMs can make mistakes. Check important info.

The provided JSON represents a JavaScript benchmark test case that compares the performance of two popular functional programming libraries: Lodash and Ramda.

**What is being tested?**

In this benchmark, three different approaches are compared:

1. **Lodash**: The first approach uses Lodash to perform the following operations on the `data` array:
	* `_.chain(data)` creates a pipeline of operations.
	* `.map('counter')` extracts the 'counter' property from each item in the array.
	* `.filter(isOdd)` filters out odd items based on the `isOdd` function.
	* `.map(square)` squares the remaining items using the `square` function.
	* `.filter(lessThanThreeDigits)` filters out items with two or more digits.
	* `.value()` returns the final result as an array of squared values with less than two digits.

2. **Ramda without relying on currying or composition**: The second approach uses Ramda to perform the following operations on the `data` array:
	* `R.filter(lessThanThreeDigits, R.map(square, R.filter(isOdd, R.pluck('counter', data))))`
	* This is a chain of functions that extracts 'counter' properties, filters out odd items, squares the remaining items, and then filters out items with two or more digits.

3. **Ramda with currying and composition**: The third approach uses Ramda to perform the following operations on the `data` array:
	* `R.pipe(R.pluck('counter'), R.filter(isOdd), R.map(square), R.filter(lessThanThreeDigits))(data)`
	* This is a chain of functions that extracts 'counter' properties, filters out odd items, squares the remaining items, and then filters out items with two or more digits.

**Pros and Cons:**

1. **Lodash**:
	* Pros: Lodash is widely used, well-maintained, and has a large community.
	* Cons: Can be bloated and may introduce unnecessary dependencies due to its extensive set of functions.
2. **Ramda without relying on currying or composition**: 
	* Pros: This approach avoids the need for currying and composition, making it easier to read and understand for some developers.
	* Cons: May result in less concise code compared to Ramda's piping syntax.
3. **Ramda with currying and composition**:
	* Pros: Piping syntax can be more expressive and concise than using individual functions.
	* Cons: Can be difficult to read for developers unfamiliar with functional programming concepts.

**Other considerations:**

* **Library purpose**: Lodash is a utility library that provides a large set of functions for common tasks, while Ramda is a functional programming library designed to help developers write more expressive and concise code.
* **Special JS feature or syntax**: The benchmark does not use any special JavaScript features or syntax.

**Alternative approaches:**

Other alternatives could include using other functional programming libraries like Immutable.js or Svelte, or implementing the pipeline logic in native JavaScript without relying on libraries.

Latest run results:

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

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

Browser/OS: Firefox 86 on Mac OS X 11.2

View result in a separate tab

Test name	Executions per second
Lodash	2639.9 Ops/sec
Ramda without relying on currying or composition	1301.9 Ops/sec
Ramda with currying and composition	1203.2 Ops/sec

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 27 days ago):