Benchmark: Ramda vs. Lodash2

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

LLMs can make mistakes. Check important info.

**Benchmark Explanation**

The provided JSON represents a benchmark test between Lodash, Ramda, and native JavaScript for a specific task. The task is to:

1. Pull the "counter" property from each item in an array of 10,000 elements.
2. Filter out odd items.
3. Square the remaining even numbers.
4. Return only those squared values that have less than two digits.

**Options Compared**

Three options are compared:

1. **Lodash**: Uses the `chain()` function to create a pipeline of operations, applying each step in sequence.
	* Pros: Easy to read and maintain, well-documented, and widely adopted library.
	* Cons: May incur overhead due to the chain creation process.
2. **Ramda without relying on currying or composition**: Uses the `filter()`, `map()`, and `pluck()` functions directly, applying each operation individually.
	* Pros: Can be more efficient since no extra processing is required for chaining.
	* Cons: May require more manual effort to read and maintain, as the operations are not pipelined.
3. **Ramda with currying and composition**: Uses the `pipe()`, `pluck()`, `filter()`, `map()`, and `filter()` functions in a composed pipeline.
	* Pros: Can be highly efficient since each operation is optimized for performance.
	* Cons: May require more expertise to read and maintain, as the operations are composed and pipelined.

**Library Considerations**

The benchmark uses two popular JavaScript libraries:

1. **Lodash**: A widely adopted library that provides a comprehensive set of utility functions, including `chain()` and other functions used in the benchmark.
2. **Ramda**: Another popular functional programming library that provides a set of higher-order functions, such as `filter()`, `map()`, and `pluck()`, which are used in the benchmark.

**Special JavaScript Features**

The benchmark does not explicitly use any special JavaScript features or syntax. However, it assumes that the browser environment supports the following:

1. **ECMAScript 6 (ES6) features**: Such as template literals (`var data = _.range(10000).map(function(i) { ... });`) and arrow functions (`function isOdd(num) { return num % 2 === 1; }`).
2. **JavaScript runtime optimizations**: Such as the ability to execute JavaScript code in a web browser context.

**Alternative Approaches**

Other approaches that could be used for this benchmark include:

1. **Native JavaScript only**: Implementing the pipeline of operations using native JavaScript functions, such as `Array.prototype.filter()`, `Array.prototype.map()`, and `String.prototype.length`.
2. **Other functional programming libraries**: Such as Slick, Underscore.js, or Lo-Dash, which provide similar functionality to Ramda.
3. **Just-In-Time (JIT) compilation**: Compiling the benchmark code using a JIT compiler to optimize performance.

These alternative approaches could be used to compare their performance with Lodash and Ramda, but would likely require significant changes to the benchmark code and infrastructure.

Latest run results:

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

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

Browser/OS: Chromium 68 on Ubuntu

View result in a separate tab

Test name	Executions per second
Lodash	1036.3 Ops/sec
Ramda without relying on currying or composition	598.0 Ops/sec
Ramda with currying and composition	594.7 Ops/sec

Related benchmarks:

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