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

vanilla v2

1K/s

Underscore

900/s

Vanilla v1

343/s

Ramda with currying and composition

337/s

Ramda without relying on currying or composition

323/s

Lodash

267/s

View exact numbers

Test name	Executions per second
✓ vanilla v2	1,237 Ops/sec
Underscore	900 Ops/sec
Vanilla v1	343 Ops/sec
Ramda with currying and composition	337 Ops/sec
Ramda without relying on currying or composition	323 Ops/sec
Lodash	267 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year 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.

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

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: 8 years ago by: Guest

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

Fastest: N/A

Slowest: N/A

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

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

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: 8 years ago by: Guest

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

Fastest: N/A

Slowest: N/A

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

Related benchmarks

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`