Benchmark: Lodash vs Ramda vs Underscore 1.9.0 - IE11 Compatible with vanilla

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(function(m) {return m.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(function(item) {return item.counter;}) .filter(isOdd) .map(square) .filter(lessThanThreeDigits) .value();
Vanilla v1
var result = data.map(function(x) {return x.counter}) .filter(isOdd) .map(square) .filter(lessThanThreeDigits)
vanilla v2
var result = []; for (var i = 0, len = data.length; i < len; i++) { if (isOdd(data[i].counter)){ var r = square(data[i].counter); if (lessThanThreeDigits(r)) { result.push(r); } } }

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
Vanilla v1
vanilla v2

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36 Edg/131.0.0.0

Browser/OS: Chrome 131 on Windows

View result in a separate tab

Test name	Executions per second
Lodash	266.9 Ops/sec
Ramda without relying on currying or composition	322.7 Ops/sec
Ramda with currying and composition	337.0 Ops/sec
Underscore	900.1 Ops/sec
Vanilla v1	342.6 Ops/sec
vanilla v2	1236.8 Ops/sec

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

LLMs can make mistakes. Check important info.

**Overview of the Benchmark**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks, comparing the performance of different libraries and approaches. The benchmark in question tests four variations: Lodash, Ramda without currying or composition, Ramda with currying and composition, Underscore, Vanilla v1, and Vanilla v2.

**What is being tested?**

The benchmark tests various data processing operations on a large dataset (10,000 objects with a counter property) to evaluate the performance of different libraries and approaches. Specifically:

* Filtering: `isOdd` function checks if an odd number is present.
* Mapping: square function squares a given number.
* Filtering again: another `isOdd` function checks if a value is within three digits.

The test uses a loop-free approach (without using `forEach`, `map`, or other loops) for Vanilla v2 and Ramda without currying or composition, while the others use their respective libraries' chainable methods (`_.chain`, `R.pipe`, etc.).

**Options compared**

* Lodash: uses its `_` variable as a global object to create a chain of operations.
* Ramda: has two approaches:
	+ Ramda with currying and composition (uses `R.pipe` to create a pipeline of functions).
	+ Ramda without relying on currying or composition (uses the `filter`, `map`, etc. functions directly, bypassing the `pipe` method).
* Underscore: uses its `_` variable as a global object to create a chain of operations.
* Vanilla v1 and v2: use loops instead of functional programming.

**Pros and Cons**

* Lodash: has a large number of utility functions, which might lead to slower performance due to the overhead of function creation and execution. However, its `chain` method can be efficient if used carefully.
* Ramda: provides a modular and composable API, but its use of currying and composition requires understanding its syntax. Without currying or composition, it uses standard JavaScript functions, which might lead to slower performance due to the overhead of function creation and execution.
* Underscore: has a similar approach to Lodash, using `chain` to create a pipeline of operations.
* Vanilla v1 and v2: use loops, which can be faster than functional programming but may not be as concise or readable.

**Library details**

* Lodash: a popular utility library for JavaScript that provides a wide range of functions for tasks like string manipulation, array processing, and more. In this benchmark, it uses the `chain` method to create a chain of operations.
* Ramda: a functional programming library for JavaScript that provides a modular and composable API. It's designed for data processing and manipulation. In this benchmark, it's used with two different approaches: currying and composition (using `R.pipe`) and without relying on these features.
* Underscore: a utility library similar to Lodash, providing functions for tasks like string manipulation, array processing, and more. It uses the `_` variable as a global object to create a chain of operations.

**Conclusion**

The benchmark highlights the trade-offs between using libraries with built-in chaining methods (Lodash, Ramda, Underscore) versus using standard JavaScript functions or loops (Vanilla v1 and v2). While these libraries provide concise and readable code, they may come at the cost of slower performance due to function creation and execution overhead. On the other hand, loops can be faster but may not be as expressive or readable. The choice ultimately depends on the specific use case and personal preference.

Related benchmarks:

Lodash vs Ramda vs Underscore 1.9.0 - IE11 Compatible with vanilla (version: 0)

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

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

Vanilla v1

vanilla v2

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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