Benchmark: Rambda vs. Lodash

Rambda vs. Lodash (version: 0)

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: Lodash vs Rambda without relying on currying or composition vs Rambda with currying and composition

Created: 6 years ago by: Guest

Jump to the latest result

HTML Preparation code:

<script src="https://unpkg.com/rambda@4.5.0/dist/rambda.umd.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.15/lodash.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.15/lodash.fp.min.js"></script>

Script Preparation code:

var fp = _.noConflict();

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('counter') .filter(isOdd) .map(square) .filter(lessThanThreeDigits) .value();
Rambda without relying on currying or composition
var result = R.filter(lessThanThreeDigits, R.map(square, R.filter(isOdd, R.pluck('counter', data))));
Rambda with currying and composition
var result = R.pipe( R.pluck('counter'), R.filter(isOdd), R.map(square), R.filter(lessThanThreeDigits) )(data);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash
Rambda without relying on currying or composition
Rambda with currying and composition

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36 Edg/133.0.0.0

Browser/OS: Chrome 133 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Lodash	4982.1 Ops/sec
Rambda without relying on currying or composition	4566.1 Ops/sec
Rambda with currying and composition	4549.4 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

The provided benchmark definition and individual test cases compare the performance of three approaches: Lodash, Ramda (without relying on currying or composition), and Ramda (with currying and composition). The task at hand is to filter out odd items from an array, square the remaining even items, and return those with less than two digits.

**Options compared:**

1. **Lodash**: A popular JavaScript utility library that provides a wide range of functions for data manipulation, string manipulation, and more.
2. **Ramda (without currying)**: Ramda is a functional programming library that provides a different set of functions for data manipulation, filtering, mapping, reducing, and more. The "without relying on currying or composition" approach means using individual functions without composing them together.
3. **Ramda (with currying and composition)**: This approach uses Ramda's currying feature to create higher-order functions that can be composed together. Currying allows you to pass a single function as an argument to another function, effectively "currying" the function.

**Pros and Cons of each approach:**

1. **Lodash**: Pros:
	* Familiarity: Lodash is widely used and has a large community, making it easy to find resources and support.
	* Performance: Lodash's implementation of various functions can be optimized for performance.
Cons:
	* Bloat: Lodash adds extra weight to your codebase with its utility functions.
	* Complexity: With so many options, using the right function can be overwhelming.
2. **Ramda (without currying)**: Pros:
	* Simplicity: Using individual Ramda functions without currying can result in more straightforward code.
Cons:
	* Verbosity: Composing multiple functions together can lead to longer and more complex code.
3. **Ramda (with currying and composition)**: Pros:
	* Expressiveness: Curried functions allow for more concise and expressive code.
Cons:
	* Steep learning curve: Understanding Ramda's currying mechanism and composing functions requires practice.

**Library usage and special JS features:**

In the benchmark definition, Lodash is used with `_.chain()`, which allows chaining multiple functions together. This feature enables more readable and efficient data manipulation code.

There are no special JavaScript features or syntax mentioned in this benchmark. However, it's worth noting that some modern browsers support features like async/await, promises, and decorators, which can also impact performance.

**Other alternatives:**

For similar use cases, you might consider using other libraries or frameworks, such as:

1. **Underscore.js**: Another popular utility library with a similar functionality to Lodash.
2. **Mocha**: A testing framework that could be used for benchmarking instead of MeasureThat.net.
3. **Benchmark.js**: A dedicated benchmarking library for JavaScript.
4. **V8 Benchmark**: A set of benchmarks developed by Google for measuring the performance of V8, the JavaScript engine used in Chrome.

These alternatives might offer different features, trade-offs, or even more efficient implementations for your specific use case.

Related benchmarks: