Benchmark: Ramda vs. Lodash (Fixed & IIFE updated zero)

Ramda vs. Lodash (Fixed & IIFE updated zero) (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: Native vs Lodash vs Ramda with currying and composition vs Ramda vs Native pipe

Created: 4 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.5/lodash.min.js"></script>

Script Preparation code:

var data = Array(10000).fill(0).map(function(x, 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:

Native
const result = []; for (const { counter } of data) { if (isOdd(counter)) { const s = square(counter); if (lessThanThreeDigits(s)) { result.push(s); } } }
Lodash
var result = _.chain(data) .map('counter') .filter(isOdd) .map(square) .filter(lessThanThreeDigits) .value();
Ramda with currying and composition
var result = R.pipe( R.pluck('counter'), R.filter(isOdd), R.map(square), R.filter(lessThanThreeDigits) )(data);
Ramda
var result = R.filter(lessThanThreeDigits, R.map(square, R.filter(isOdd, R.pluck('counter', data))));
Native pipe
const result = data.map(({counter}) => counter).filter(isOdd).map(square).filter(lessThanThreeDigits);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Native
Lodash
Ramda with currying and composition
Ramda
Native pipe

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.

**Benchmark Overview**

The provided JSON represents a benchmarking test that compares the performance of four different approaches:

1. Lodash (using its built-in functions)
2. Ramda (a functional programming library)
3. Native JavaScript (without any libraries)
4. Ramda with currying and composition

The benchmark tests the execution time of an array processing task: filtering out odd numbers, squaring them, and returning only those with less than two digits.

**Options Compared**

Here's a breakdown of each option:

1. **Lodash**: The benchmark uses Lodash's `chain()` method to create a pipeline of operations. It filters out odd numbers, maps the counter values to squares, filters the results for values with less than two digits, and finally returns the result.
2. **Ramda with currying and composition**: Ramda is used with its functional programming style. The benchmark uses `R.pipe()` to create a pipeline of operations: plucking the 'counter' value from each object in the array, filtering out odd numbers, mapping squares, and filtering for values with less than two digits.
3. **Native JavaScript (Lodash-style)**: This option is similar to Lodash but without using its library. The benchmark uses `_.chain()`-style functions to create a pipeline of operations.
4. **Native JavaScript (Ramda-style)**: This option uses Ramda's functional programming style directly in the code, without referencing the library.

**Pros and Cons**

Here are some pros and cons for each approach:

1. **Lodash**: Pros:
	* Well-maintained and optimized performance.
	* Easy to read and understand.
Cons:
	* Requires importing Lodash library.
2. **Ramda with currying and composition**: Pros:
	* Highly expressive and concise code.
	* Utilizes Ramda's functional programming style efficiently.
Cons:
	* Steeper learning curve due to new syntax.
3. **Native JavaScript (Lodash-style)**: Pros:
	* Easy to read and understand, similar to Lodash.
Cons:
	* Less optimized performance compared to actual Lodash usage.
4. **Native JavaScript (Ramda-style)**: Pros:
	* Utilizes Ramda's functional programming style directly in the code.
Cons:
	* Requires a good understanding of Ramda's API.

**Other Considerations**

When choosing between these options, consider the following factors:

1. Performance: If performance is critical, Lodash or Ramda with currying and composition might be a better choice due to their optimized implementations.
2. Readability: Native JavaScript (Lodash-style) or Ramda (without currying/composition) might be easier to read and understand for developers familiar with the libraries.
3. Learning curve: If you're new to functional programming, Ramda with currying and composition might require more effort to grasp.

**Library Overview**

In this benchmark, Lodash is a popular JavaScript utility library that provides a comprehensive set of functions for tasks like array manipulation, object manipulation, and string manipulation.

Ramda is another functional programming library that aims to provide a more concise and expressive way of working with data. It's designed to be a more lightweight alternative to Lodash.

The `R` prefix in Ramda refers to the root namespace of the library, which contains all its functions and methods.

**Special JS Features/Syntax**

This benchmark does not explicitly mention any special JavaScript features or syntax, such as ES modules, classes, generators, or async/await. However, it's worth noting that modern JavaScript has a wide range of features that can affect performance and code readability.

Latest run results:

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

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

Browser/OS: Chrome 88 on Linux

View result in a separate tab

Test name	Executions per second
Native	636.2 Ops/sec
Lodash	1726.8 Ops/sec
Ramda with currying and composition	627.6 Ops/sec
Ramda	630.0 Ops/sec
Native pipe	1569.2 Ops/sec

Related benchmarks:

Ramda vs. Lodash (Fixed & IIFE updated zero) (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: Native vs Lodash vs Ramda with currying and composition vs Ramda vs Native pipe

Created: 4 years ago by: Guest

Jump to the latest result

Native

Lodash

Ramda with currying and composition

Ramda

Native pipe

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