Benchmark: Ramda vs. Lodash updated again

Ramda vs. Lodash updated again (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: 3 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.15/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.

Let's break down the provided benchmark and explain what's being tested.

**Benchmark Overview**

The benchmark compares the performance of three approaches:

1. **Lodash**: A popular JavaScript utility library that provides various functions for tasks like array manipulation, string processing, and more.
2. **Ramda (without currying or composition)**: Ramda is a functional programming library for JavaScript that provides a different set of functions for array manipulation, data transformation, and other tasks.
3. **Ramda (with currying and composition)**: An updated version of Ramda that uses currying (function application) and composition to create more expressive and reusable functions.

**Benchmark Definition**

The benchmark definition is provided in the "Script Preparation Code" section. The task at hand is to:

* Pull the "counter" property from each item in an array (`data`)
* Filter out odd items
* Square the remaining items
* Return only those squared values that have less than two digits

**Options Compared**

The three options compared are:

1. **Lodash**: Uses its `chain` function to create a pipeline of operations, where each operation is applied in sequence.
2. **Ramda (without currying or composition)**: Uses its built-in functions like `filter`, `map`, and `pluck` directly.
3. **Ramda (with currying and composition)**: Uses its `pipe` function to compose multiple functions together, effectively creating a pipeline of operations.

**Pros and Cons**

Here's a brief summary of the pros and cons for each approach:

1. **Lodash**:
	* Pros:
		+ Easy to read and maintain due to its functional programming style.
		+ Fast execution since it avoids explicit function calls.
	* Cons:
		+ May be less efficient than other approaches due to the creation of a new scope for each operation in the pipeline.
2. **Ramda (without currying or composition)**:
	* Pros:
		+ Can be more efficient than Lodash since it doesn't create a new scope for each operation.
	* Cons:
		+ Less readable and maintainable due to its imperative programming style.
		+ May require more manual memory management (e.g., using `arguments.callee`).
3. **Ramda (with currying and composition)**:
	* Pros:
		+ Can be more efficient than Lodash since it avoids explicit function calls.
		+ Provides a higher-level abstraction, making the code more concise and readable.
	* Cons:
		+ May require more expertise in functional programming to understand and maintain.

**Library Usage**

The benchmark uses Ramda for its `chain`, `filter`, `map`, and `pluck` functions. It also uses Lodash for its `chain` function, which is similar but provides a different set of operations.

**Special JS Features or Syntax**

None are mentioned in the provided benchmark definition. However, it's worth noting that Ramda's currying and composition features require a good understanding of functional programming concepts.

**Other Alternatives**

If you're interested in exploring other alternatives for this benchmark, here are some options:

* **JQuery**: A popular JavaScript library for DOM manipulation and event handling.
* **Underscore.js**: Another utility library similar to Lodash, but with a different set of functions.
* **Purescript**: A functional programming language that compiles to JavaScript, which could potentially provide more efficient execution.

Keep in mind that these alternatives may not be directly comparable to the Ramda benchmark due to their differing design principles and use cases.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.114 Safari/537.36 Edg/89.0.774.68

Browser/OS: Chrome 89 on Windows

View result in a separate tab

Test name	Executions per second
Lodash	1018.3 Ops/sec
Ramda without relying on currying or composition	414.2 Ops/sec
Ramda with currying and composition	390.1 Ops/sec

Related benchmarks:

Ramda vs. Lodash updated again (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: 3 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):