Benchmark: Lodash vs Ramda vs Underscore 1.9.0

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.25.0/ramda.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.4/lodash.js"></script>
<script type="text/javascript">
  window.lodash = _;
  _ = null;
</script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.9.0/underscore.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 = lodash.chain(data) .map(item => item.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);
Underscore
var result = _.chain(data) .map(item => item.counter) .filter(isOdd) .map(square) .filter(lessThanThreeDigits) .value();

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
Underscore

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 7 months ago)

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

Browser/OS: Mobile Safari 17 on iOS 17.4.1

View result in a separate tab

Test name	Executions per second
Lodash	1123.9 Ops/sec
Ramda without relying on currying or composition	824.6 Ops/sec
Ramda with currying and composition	802.4 Ops/sec
Underscore	1109.9 Ops/sec

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

LLMs can make mistakes. Check important info.

The provided benchmark is designed to compare the performance of three JavaScript libraries: Lodash, Ramda, and Underscore.js (version 1.9.0). The benchmark focuses on a specific set of functions that filter, map, and transform an array of data.

**Benchmark Description**

The test data consists of an array of 10,000 objects, each with a single property called "counter". The objective is to filter out the odd numbers from this array, square the remaining numbers, and then filter out those numbers that have three digits or less.

**Comparison of Options**

There are three main approaches being compared:

1. **Lodash**: Uses the `_.chain()` method to create a pipeline of functions that filters, maps, and transforms the data. This approach relies on Lodash's functional programming features.
2. **Ramda**: Offers two different implementations:
	* **Without relying on currying or composition**: Uses the `R.filter()`, `R.map()`, and `R.pluck()` functions to achieve the same result as the pipeline in Lodash. However, this approach does not utilize Ramda's curried function notation.
	* **With currying and composition**: Utilizes Ramda's functional programming features, including currying (`R.pipe()`) and composition (`R.compose()`) to create a more concise and expressive solution.

**Pros and Cons**

Here are some pros and cons of each approach:

1. **Lodash**:
	* Pros: Easy to read and maintain, leverages Lodash's extensive library of utility functions.
	* Cons: May be slower due to the overhead of creating a pipeline.
2. **Ramda (Without currying)**:
	* Pros: Simple and straightforward, easy to understand for developers familiar with functional programming concepts.
	* Cons: May not be as concise or expressive as Ramda's curried implementation.
3. **Ramda (With currying)**:
	* Pros: More concise and expressive than the non-curried version, leverages Ramda's functional programming features.
	* Cons: May require more time to understand and grasp the concept of currying.

**Library Descriptions**

1. **Lodash**: A popular JavaScript library that provides a comprehensive set of utility functions for functional programming, including filtering, mapping, and transforming arrays.
2. **Ramda**: A functional programming library for JavaScript that offers a different approach to functional programming than Lodash. Ramda emphasizes currying and composition to create concise and expressive solutions.

**Special JS Features or Syntax**

The benchmark uses some advanced JavaScript features and syntax:

1. Currying (e.g., `R.pipe()`, `_.chain()`): allows functions to be defined with a variable number of arguments, making them more flexible and reusable.
2. Composition (e.g., `R.compose()`: allows functions to be combined in a pipeline-like fashion, enabling the creation of complex transformations in a modular way.

**Alternatives**

If you're interested in exploring other JavaScript libraries or alternatives for functional programming, here are some options:

1. **Purescript**: A statically typed functional programming language that compiles to JavaScript.
2. **Curry**: A library that provides a different approach to currying and composition.
3. **JavaScript Functional Programming**: Various online resources, tutorials, and books that explore the principles of functional programming in JavaScript.

I hope this explanation helps you understand the benchmark and its comparison of different libraries!

Related benchmarks:

Lodash vs Ramda vs Underscore 1.9.0 (version: 0)

Comparing performance of: Lodash vs Ramda without relying on currying or composition vs Ramda with currying and composition vs Underscore

Created: 6 years ago by: Guest

Jump to the latest result

Lodash

Ramda without relying on currying or composition

Ramda with currying and composition

Underscore

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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