Benchmark: List operations: Ramda vs. Lodash vs. Immutable vs. Native array methods

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.5/lodash.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/immutable/4.3.4/immutable.min.js"></script>

Script Preparation code:

var data = _.range(10000).map(function(i) {
  return {
    counter: i
  }
});

function isOdd({ counter }) {
  return counter % 2 === 1;
}

function square({ counter }) {
  return counter * counter;
}

function lessThanThreeDigits(value) {
  return value.toString().length < 3;
}

Tests:

Lodash
var result = _.chain(data) .filter(isOdd) .map(square) .filter(lessThanThreeDigits) .value();
Ramda compose
var result = R.compose( R.filter(lessThanThreeDigits), R.map(square), R.filter(isOdd) )(data);
Ramda pipe
var result = R.pipe( R.filter(isOdd), R.map(square), R.filter(lessThanThreeDigits) )(data);
Immutable List
var result = Immutable.List(data) .filter(isOdd) .map(square) .filter(lessThanThreeDigits) .toArray();
Immutable Seq
var result = Immutable.Seq(data) .filter(isOdd) .map(square) .filter(lessThanThreeDigits) .toArray();
Native
var result = data .filter(isOdd) .map(square) .filter(lessThanThreeDigits);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash
Ramda compose
Ramda pipe
Immutable List
Immutable Seq
Native

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 17_2_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 17 on iOS 17.2.1

View result in a separate tab

Test name	Executions per second
Lodash	4956.0 Ops/sec
Ramda compose	4635.8 Ops/sec
Ramda pipe	4440.8 Ops/sec
Immutable List	537.4 Ops/sec
Immutable Seq	3693.9 Ops/sec
Native	4336.4 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided JSON represents a JavaScript microbenchmarking test case, specifically designed to compare the performance of different libraries and native array methods for executing list operations on a large dataset.

**Benchmarked Libraries and Methods**

The benchmark compares six approaches:

1. **Lodash**: A popular utility library that provides functional programming helpers.
2. **Ramda compose**: A higher-order function composition library that allows for function chaining.
3. **Ramda pipe**: Another function composition library, similar to Ramda compose, but with a different API.
4. **Immutable List**: A library from the Immutable.js project that provides immutable data structures and functions.
5. **Immutable Seq**: A sequential version of the Immutable List data structure.
6. **Native Array Methods**: Using native JavaScript array methods for list operations.

**Options Compared**

The benchmark compares the performance of each approach on a dataset of 10,000 elements, with the following steps:

* Filtering out odd numbers using `isOdd`
* Squaring the remaining numbers using `square`
* Filtering out numbers with less than three digits using `lessThanThreeDigits`

**Pros and Cons of Each Approach**

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

1. **Lodash**: Pros: Easy to use, well-maintained. Cons: Larger library size, potentially slower performance due to function overhead.
2. **Ramda compose**: Pros: Expressive API, flexible function chaining. Cons: Steeper learning curve, potentially slower performance due to function composition overhead.
3. **Ramda pipe**: Pros: Similar to Ramda compose, but with a more concise API. Cons: Same limitations as Ramda compose.
4. **Immutable List**: Pros: Immutable data structures provide predictable behavior and thread safety. Cons: Larger library size, potentially slower performance due to immutability overhead.
5. **Immutable Seq**: Pros: Sequential data structure provides efficient iteration. Cons: Limited use cases compared to Immutable List.
6. **Native Array Methods**: Pros: Fastest execution time, smallest library size. Cons: Less predictable behavior, no thread safety guarantees.

**Library and Method Descriptions**

1. **Lodash`**: A utility library that provides various functions for working with arrays, objects, and other data structures.
2. **Ramda compose`**: A higher-order function composition library that allows for function chaining to create complex functions.
3. **Ramda pipe`**: Another function composition library similar to Ramda compose, but with a more concise API.
4. **Immutable.js**: A library for working with immutable data structures and functions.
5. **Native Array Methods`: JavaScript array methods such as `filter()`, `map()`, and `forEach()`.

**Special JS Feature or Syntax**

The benchmark uses the following special features:

1. **Higher-order functions`**: Functions that take other functions as arguments, such as Ramda compose and pipe.
2. **Immutable data structures`**: Data structures that cannot be changed in place, such as Immutable List and Seq.

By comparing these approaches, we can gain insights into the performance characteristics of each library and method, helping us make informed decisions about which ones to use in our own projects.

Related benchmarks:

List operations: Ramda vs. Lodash vs. Immutable vs. Native array methods (version: 0)

Comparing performance of: Lodash vs Ramda compose vs Ramda pipe vs Immutable List vs Immutable Seq vs Native

Created: 2 years ago by: Guest

Jump to the latest result

Lodash

Ramda compose

Ramda pipe

Immutable List

Immutable Seq

Native

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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