Benchmark: Lodash vs Ramda vs Native 2020-09-01

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.27.1/ramda.min.js" integrity="sha512-rZHvUXcc1zWKsxm7rJ8lVQuIr1oOmm7cShlvpV0gWf0RvbcJN6x96al/Rp2L2BI4a4ZkT2/YfVe/8YvB2UHzQw==" crossorigin="anonymous"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.20/lodash.min.js" integrity="sha512-90vH1Z83AJY9DmlWa8WkjkV79yfS2n2Oxhsi2dZbIv0nC4E6m5AbH8Nh156kkM7JePmqD6tcZsfad1ueoaovww==" crossorigin="anonymous"></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

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

LLMs can make mistakes. Check important info.

Measuring the performance of JavaScript libraries can be a complex task, as it depends on various factors such as the specific use case, data size, and hardware configuration.

The provided benchmark tests three different approaches:

1. **Native**: This is the native JavaScript implementation without using any external libraries. It uses standard JavaScript functions like `map`, `filter`, and `reduce`.
2. **Lodash**: This approach uses the popular Lodash library, which provides a set of functional programming helpers. In this benchmark, it's used for its `chain` function, which helps to compose multiple operations in a predictable order.
3. **Ramda**: This is another functional programming library that provides a different set of helper functions. The benchmark tests two approaches: one without relying on currying or composition (similar to Lodash), and another with currying and composition.

Now, let's discuss the pros and cons of each approach:

**Native**:
Pros:

* No external dependencies
* Fast execution since it doesn't involve library overhead

Cons:

* May be slower due to the need to implement the filtering and mapping logic manually
* Error-prone if the implementation is incorrect or incomplete

**Lodash**:
Pros:

* Well-maintained and widely-used library with a large community
* Provides a robust set of functional programming helpers

Cons:

* Adds external dependency, which may impact performance
* May be slower due to the library's overhead

**Ramda**:
Pros:

* Similar to Lodash, provides a robust set of functional programming helpers
* Allows for currying and composition, which can lead to more efficient code

Cons:

* Also adds an external dependency
* May be slower due to the library's overhead

Other considerations:

* **Currying and Composition**: Ramda's approach using currying and composition can lead to more efficient code, but it requires a good understanding of functional programming concepts. Lodash also provides similar functionality.
* **Library Overhead**: Both Lodash and Ramda introduce additional overhead due to their external dependencies. However, this overhead is typically small compared to the benefits of using these libraries.

**Test Case Analysis**:

The individual test cases demonstrate different approaches to achieving the same result. Here's a brief analysis:

1. **Native**: This approach uses standard JavaScript functions to perform filtering and mapping.
2. **Lodash (without currying/composition)**: Uses Lodash's `chain` function to compose multiple operations.
3. **Ramda (without currying/composition)**: Similar to the previous case, using Ramda's `filter` and `map` functions directly.
4. **Ramda (with currying/composition)**: Uses Ramda's `pipe` function to chain together multiple operations.

In summary, the choice between these approaches depends on the specific requirements of your project. If you need a fast, lightweight solution with minimal dependencies, Native might be a good choice. However, if you prioritize readability and maintainability, using a library like Lodash or Ramda can lead to more efficient code.

Latest run results:

Run details: (Test run date: one month ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:131.0) Gecko/20100101 Firefox/131.0

Browser/OS: Firefox 131 on Mac OS X 10.15

View result in a separate tab

Test name	Executions per second
Lodash	2977.3 Ops/sec
Ramda without relying on currying or composition	619.7 Ops/sec
Ramda with currying and composition	360.2 Ops/sec
Native	3015.1 Ops/sec

Related benchmarks:

Lodash vs Ramda vs Native 2020-09-01 (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: 4 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>

Experimental features:

Fastest: N/A

Slowest: N/A

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