Benchmark: Ramda vs. Lodash + Immutable 1

Ramda vs. Lodash + Immutable 1 (version: 1)

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 vs Immutable

Created: 5 years ago by: Registered User

Jump to the latest result

HTML Preparation code:

<script src="https://unpkg.com/ramda@0.25.0/dist/ramda.min.js"></script>
<script src="https://unpkg.com/lodash@4.17.10/lodash.js"></script>
<script src="https://unpkg.com/immutable@4.0.0-rc.9/dist/immutable.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;
}

var immutableData = Immutable
	.Seq(data);
console.log(1);

Tests:

Lodash
var result = _.chain(data) .map('counter') .filter(isOdd) .map(square) .filter(lessThanThreeDigits) .value(); console.log(2);
Ramda without relying on currying or composition
var result = R.filter(lessThanThreeDigits, R.map(square, R.filter(isOdd, R.pluck('counter', data)))); console.log(3);
Ramda with currying and composition
var result = R.pipe( R.pluck('counter'), R.filter(isOdd), R.map(square), R.filter(lessThanThreeDigits) )(data); console.log(4);
Immutable
var result = immutableData .map(({ counter }) => counter) .filter(isOdd) .map(square) .filter(lessThanThreeDigits); console.log(5);

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
Immutable

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):

LLMs can make mistakes. Check important info.

This is a complex benchmark test, so let's break it down step by step.

**Benchmark Overview**

The benchmark tests four approaches to perform the same task:

1. Lodash (with chaining)
2. Ramda (without relying on currying or composition) vs. Ramda (with currying and composition)
3. Immutable.js

The task involves:

* Creating an array of 10,000 objects with a "counter" property
* Filtering out odd-numbered items
* Squaring the remaining even-numbered items
* Filtering out items with less than two digits
* Returning the squared values that meet this condition

**Options Compared**

1. **Lodash (with chaining)**: Uses the `_.chain()` method to create a pipeline of functions, where each function is applied to the result of the previous one.
2. **Ramda without currying or composition**: Uses Ramda's functional programming API to define separate functions for filtering, squaring, and filtering again. These functions are then chained together using the `R.` prefix.
3. **Ramda with currying and composition**: Similar to the previous option, but uses Ramda's curried functions (e.g., `R.filter`) and composition syntax (e.g., `R.pipe`) to define a single function that performs all three operations.
4. **Immutable.js**: Uses Immutable.js's data structure (a seq) to transform the original array.

**Pros and Cons of Each Approach**

1. **Lodash (with chaining)**:
	* Pros: Easy to read and understand, familiar syntax for Lodash users.
	* Cons: Chaining can lead to slower performance due to repeated function calls.
2. **Ramda without currying or composition**:
	* Pros: Allows for explicit control over the pipeline and avoids potential overhead of currying/composition.
	* Cons: May require more boilerplate code and is less familiar to users without Ramda experience.
3. **Ramda with currying and composition**:
	* Pros: Enables concise and expressive code, reduces boilerplate, and can be faster due to optimization of the pipeline.
	* Cons: Requires understanding of Ramda's syntax and functional programming concepts.
4. **Immutable.js**:
	* Pros: Offers a high-level abstraction for data transformations, which can lead to more efficient execution.
	* Cons: May require additional setup and learning curve due to its unique API.

**Library/ Framework Details**

1. **Lodash**: A popular utility library that provides a wide range of functions for array manipulation, string manipulation, and more.
2. **Ramda**: A functional programming library that provides a set of immutable data structures and operations for working with them.
3. **Immutable.js**: A library that allows you to work with immutable data structures in JavaScript, making it easier to reason about your code and avoid side effects.

**Special JS Features or Syntax**

The benchmark uses various ES6+ features such as:

* `async` functions (although not explicitly used here)
* `const` and `let` declarations
* Template literals (e.g., `"var result = _.chain(data)..."`)

These features are used to define the test cases and prepare the data, but they do not impact the core logic of the benchmark.

**Alternatives**

If you're looking for alternatives or inspiration, consider:

1. **Underscore.js**: Another popular utility library that provides similar functionality to Lodash.
2. **Cytus.js**: A modern alternative to Ramda, offering a more concise and expressive API.
3. **RxJS**: A reactive programming library that provides a different approach to working with data transformations.

These alternatives may offer different trade-offs in terms of performance, readability, and learning curve, so it's essential to evaluate them based on your specific needs and requirements.

Latest run results:

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

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

Browser/OS: Chrome 71 on Windows

View result in a separate tab

Test name	Executions per second
Lodash	806.2 Ops/sec
Ramda without relying on currying or composition	563.3 Ops/sec
Ramda with currying and composition	539.8 Ops/sec
Immutable	75172.8 Ops/sec

Related benchmarks:

Ramda vs. Lodash + Immutable 1 (version: 1)

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 vs Immutable

Created: 5 years ago by: Registered User

Jump to the latest result

Lodash

Ramda without relying on currying or composition

Ramda with currying and composition

Immutable

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):