Benchmark: Ramda vs. Lodash (2022)

Ramda vs. Lodash (2022) (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://cdn.jsdelivr.net/npm/ramda@0.28.0/dist/ramda.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/lodash@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 26 days ago):

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

**Overview**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks, comparing different approaches to solving a specific problem. In this case, we have a benchmark comparing the performance of Lodash versus two styles of Ramda (a functional programming library) in performing a specific task.

**Benchmark Definition**

The benchmark defines three test cases:

1. **Lodash**: Uses the `_.chain` function from Lodash to perform the following operations:
	* `_.pick('counter')`: selects only the 'counter' property from each item in the array.
	* `_.filter(isOdd)`: filters out items where the counter is even (i.e., not odd).
	* `_.map(square)`: squares the remaining odd numbers.
	* `_.filter(lessThanThreeDigits)`: filters out numbers with 3 or more digits.
	* `_.value()`: returns the final filtered and squared array.
2. **Ramda without currying**: Uses Ramda's `R` namespace to perform the following operations:
	* `R.filter(lessThanThreeDigits, R.map(square, R.filter(isOdd, data)))`: maps each item in the array to its square, filters out items where the counter is even, and then filters out numbers with 3 or more digits.
3. **Ramda with currying**: Uses Ramda's `R` namespace with currying (a functional programming technique) to perform the following operations:
	* `R.pipe(R.pluck('counter'), R.filter(isOdd), R.map(square), R.filter(lessThanThreeDigits))(data)`: pipes a series of functions together, where each function processes one step in the chain.

**Options Compared**

The three test cases compare different approaches to solving the problem:

1. **Linear execution**: The Lodash test case uses a linear sequence of operations, which can be more efficient for simple filtering and mapping tasks.
2. **Curried function composition**: The Ramda with currying test case uses a pipeline of functions, where each function processes one step in the chain. This approach can be beneficial for complex data processing tasks, as it allows for easy composition and reuse of intermediate results.
3. **Non-curried function composition**: The Ramda without currying test case also uses a non-curried version of the `R.filter` and `R.map` functions.

**Pros and Cons**

Here are some pros and cons of each approach:

1. **Lodash**: Easy to read and understand, but may not be as efficient for complex data processing tasks due to its linear execution sequence.
2. **Ramda with currying**: More flexible and composable than the non-curried version, but may require more mental overhead due to its functional programming concepts.
3. **Ramda without currying**: A balance between readability and performance, as it avoids some of the functional programming complexities while still providing a more efficient execution sequence than Lodash.

**Other Considerations**

* **Language-specific optimizations**: The benchmark may benefit from language-specific optimizations, such as JavaScript's built-in `forEach` method or Array.prototype methods.
* **Data distribution**: The data used in the benchmark (e.g., an array of consecutive integers) may not accurately represent real-world data distributions, which can affect performance results.

**Alternative Approaches**

Other alternatives to consider:

1. **Native JavaScript**: Write a custom implementation using native JavaScript functions and operators.
2. **Other functional programming libraries**: Consider alternative functional programming libraries like Lo-Dash or Purescript.
3. **Multi-threading or parallel processing**: If the task can be parallelized, consider using multi-threading or parallel processing techniques to improve performance.

These alternatives may not directly compete with the Ramda and Lodash approaches but offer interesting trade-offs in terms of complexity, flexibility, and potential performance improvements.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:98.0) Gecko/20100101 Firefox/98.0

Browser/OS: Firefox 98 on Windows

View result in a separate tab

Test name	Executions per second
Lodash	184319.7 Ops/sec
Ramda without relying on currying or composition	910.1 Ops/sec
Ramda with currying and composition	265.6 Ops/sec

Related benchmarks:

Ramda vs. Lodash (2022) (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 26 days ago):