Benchmark: Lodash vs Ramda vs Native 2023-12-24

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.29.1/ramda.min.js" integrity="sha512-PVSAmDFNqey8GMII8s9rjjkCFvUgzfsfi8FCRxQa3TkPZfdjCIUM+6eAcHIFrLfW5CTFAwAYS4pzl7FFC/KE7Q==" crossorigin="anonymous" referrerpolicy="no-referrer"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.21/lodash.min.js" integrity="sha512-WFN04846sdKMIP5LKNphMaWzU7YpMyCU245etK3g/2ARYbPK9Ub18eG+ljU96qKRCWh+quCY7yefSmlkQw1ANQ==" crossorigin="anonymous" referrerpolicy="no-referrer"></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(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);
Native
var result = data .map(x => x.counter) .filter(isOdd) .map(square) .filter(lessThanThreeDigits) ;

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
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	5940.9 Ops/sec
Ramda without relying on currying or composition	3687.2 Ops/sec
Ramda with currying and composition	2250.1 Ops/sec
Native	2384.9 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark.

**What is tested?**

The benchmark tests three different approaches to performing operations on arrays:

1. **Native**: Native JavaScript array methods, such as `map`, `filter`, and `reduce`.
2. **Lodash**: The popular JavaScript utility library Lodash, which provides a set of functions for common tasks like mapping, filtering, and transforming data.
3. **Ramda**: Another popular functional programming library, Ramda, which provides a set of higher-order functions for manipulating arrays and objects.

**Options compared**

The benchmark compares the performance of these three approaches on the same test case: mapping an array of numbers, filtering out odd numbers, squaring each number, filtering out numbers with less than 3 digits, and finally converting the result to an array.

Here are the pros and cons of each approach:

* **Native**: Pros - no dependencies, fast and efficient. Cons - requires manual implementation of complex operations.
* **Lodash**: Pros - easy to use, extensive set of functions for common tasks. Cons - adds dependency on external library, may introduce overhead.
* **Ramda**: Pros - functional programming style, easy to compose functions. Cons - introduces additional dependencies, may be less intuitive for non-functional programmers.

**Library and purpose**

* **Lodash**: A JavaScript utility library that provides a set of functions for common tasks like mapping, filtering, reducing, and transforming data.
* **Ramda**: A functional programming library that provides a set of higher-order functions for manipulating arrays and objects.

The benchmark uses Ramda's `filter` function to skip the currying step, which allows for easier composition of functions. The other two approaches use Ramda's `filter` function with currying, which introduces an additional dependency on the library.

**Special JS feature or syntax**

This benchmark does not use any special JavaScript features or syntax beyond what is required for the benchmark itself. It only uses standard ES6+ syntax and modern JavaScript features like arrow functions and template literals.

**Other alternatives**

If you're interested in exploring other options, here are a few alternatives:

* **Underscore.js**: Another popular utility library that provides a set of functions similar to Lodash.
* **Java or C++ benchmarking libraries**: If you prefer to use a non-JavaScript language, there are several benchmarking libraries available for Java and C++ that can be used to compare the performance of different approaches.

Keep in mind that each approach has its strengths and weaknesses, and the choice ultimately depends on your specific needs and preferences.

Related benchmarks:

Lodash vs Ramda vs Native 2023-12-24 (version: 0)

Tests libraries lodash, ramda and native array functions on a sequence of map, filter, map filter operations.

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

Created: 2 years ago by: Guest

Jump to the latest result

Lodash

Ramda without relying on currying or composition

Ramda with currying and composition

Native

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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