Benchmark: Ramda vs. Lodash (Fixed & IIFE updated asc)

Ramda vs. Lodash (Fixed & IIFE updated asc) (version: 3)

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: Native vs Lodash vs Ramda with currying and composition vs Ramda

Created: 4 years ago by: Registered User

Jump to the latest result

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 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:

Native
var result = (() => { var result = []; var { length } = data; for (var i = 0; i < length; i++) { var { counter } = data[i]; if (!isOdd(counter)) { continue; } var s = square(counter); if (!lessThanThreeDigits(s)) { continue; } result.push(s); } return result; })()
Lodash
var result = _.chain(data) .map('counter') .filter(isOdd) .map(square) .filter(lessThanThreeDigits) .value();
Ramda with currying and composition
var result = R.pipe( R.pluck('counter'), R.filter(isOdd), R.map(square), R.filter(lessThanThreeDigits) )(data);
Ramda
var result = R.filter(lessThanThreeDigits, R.map(square, R.filter(isOdd, R.pluck('counter', data))));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Native
Lodash
Ramda with currying and composition
Ramda

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Measuring performance of different JavaScript libraries is an essential task for any developer, and MeasureThat.net provides a great platform to compare the execution speed of various approaches.

**What is being tested?**

The provided JSON represents a benchmark test that compares the performance of four different approaches:

1. **Native**: This is the baseline approach, which uses only built-in JavaScript functions (e.g., `Array.prototype.filter()`, `Math.pow()`) without any library assistance.
2. **Lodash**: This approach relies on the popular Lodash library for its functionality.
3. **Ramda with currying and composition**: This approach utilizes the Ramda library, which is known for its functional programming principles. The test uses a combination of currying (wrapping functions in `R.pipe()` or similar) and composition to achieve the desired result.
4. **Ramda**: Similar to the previous point, but without using currying and composition.

**Options comparison**

Here's a brief overview of each approach:

*   **Native**: This approach uses only built-in JavaScript functions, which can be slower due to the overhead of function calls and type checks. However, it provides a clean and lightweight implementation that doesn't rely on external libraries.
*   **Lodash**: Lodash is a popular library for functional programming in JavaScript. It provides a wide range of utility functions, including filtering, mapping, and more. The performance impact depends on the specific Lodash function used, but generally, it can be faster than native implementations due to the optimized codebase.
*   **Ramda with currying and composition**: Ramda is designed for functional programming and provides an expressive API using curried functions (`R.pipe()`, `R.map()`) and composition. This approach can lead to more efficient code due to reduced function overhead, but it may require more effort to understand and implement.
*   **Ramda**: Similar to the previous point, but without using currying and composition. The performance should be similar to Ramda with currying and composition.

**Pros and cons**

Here's a summary of each approach:

*   **Native**:
    *   Pros: Lightweight, easy to understand
    *   Cons: May be slower due to overhead of built-in functions
*   **Lodash**:
    *   Pros: Often faster than native implementations, provides a wide range of utility functions
    *   Cons: Relies on an external library, may have performance impact due to dependency loading
*   **Ramda with currying and composition**:
    *   Pros: Can lead to more efficient code due to reduced function overhead, expressive API
    *   Cons: May be harder to understand and implement, requires knowledge of functional programming concepts
*   **Ramda**:
    *   Pros: Similar performance profile as Ramda with currying and composition, but without the additional complexity
    *   Cons: None significant

**Other considerations**

In addition to performance, other factors like code readability, maintainability, and platform compatibility should be considered when choosing a library or implementing custom functionality.

**Alternative approaches**

If you're not satisfied with the provided options, consider exploring other libraries or frameworks that cater to your specific needs. Some popular alternatives include:

*   **Underscore.js**: Another popular utility library for functional programming in JavaScript.
*   **Lo-Dash**: A variation of Lodash designed for performance-critical applications.
*   **Purescript**: A statically typed, purely functional programming language for JavaScript.

When selecting an alternative approach, carefully evaluate factors like performance, code readability, and platform compatibility to ensure the chosen library or framework aligns with your project requirements.

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36

Browser/OS: Chrome 117 on Linux

View result in a separate tab

Test name	Executions per second
Native	559.1 Ops/sec
Lodash	1893.1 Ops/sec
Ramda with currying and composition	952.8 Ops/sec
Ramda	792.0 Ops/sec

Related benchmarks:

Ramda vs. Lodash (Fixed & IIFE updated asc) (version: 3)

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: Native vs Lodash vs Ramda with currying and composition vs Ramda

Created: 4 years ago by: Registered User

Jump to the latest result

Native

Lodash

Ramda with currying and composition

Ramda

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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