Benchmark: Lodash vs Ramda vs Underscore 1.5.2

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.5.2/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(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);
Underscore
var result = _.chain(data) .map(item => item.counter) .filter(isOdd) .map(square) .filter(lessThanThreeDigits) .value();

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

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 4 years ago)

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

Browser/OS: Chrome 86 on Linux

View result in a separate tab

Test name	Executions per second
Lodash	688.6 Ops/sec
Ramda without relying on currying or composition	667.8 Ops/sec
Ramda with currying and composition	543.3 Ops/sec
Underscore	671.7 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and its various components.

**Benchmark Definition**

The benchmark is defined as a series of test cases that compare the performance of three JavaScript libraries: Lodash, Ramda, and Underscore (version 1.5.2). The test cases are designed to measure the execution time of different data processing operations on a large dataset.

**Script Preparation Code**

The script preparation code defines the necessary variables, functions, and data structures for each test case:

* `data`: an array of 10,000 objects with a single property `counter`.
* `isOdd`, `square`, and `lessThanThreeDigits` are three separate functions that perform simple calculations.
* The test cases use these functions to process the `data` array.

**Html Preparation Code**

The html preparation code includes links to load the necessary JavaScript libraries (Lodash, Ramda, and Underscore) into the testing environment.

**Test Cases**

There are four individual test cases:

1. **Lodash**: uses Lodash's chain method to process the data.
	* Breakdown:
		+ `lodash.chain(data)` creates a pipeline of functions to be applied to the data.
		+ `.map(item => item.counter)` applies the `counter` function to each object in the data array.
		+ `.filter(isOdd)` filters out objects where `isOdd(num)` returns false.
		+ `.map(square)` squares each remaining object's value using the `square` function.
		+ `.filter(lessThanThreeDigits)` filters out objects with more than 2 digits.
		+ `.value()` returns the final filtered array.
2. **Ramda without currying or composition**: uses Ramda's filter and map functions to process the data.
	* Breakdown:
		+ `R.filter(lessThanThreeDigits, R.map(square, R.filter(isOdd, R.pluck('counter', data))))`
			- `R.filter` filters out objects based on a predicate function.
			- `R.map` applies a function to each object in the array.
			- `R.pluck` extracts a specific property from each object.
			- The inner expression applies `isOdd`, then maps and squares, finally filtering based on length.
3. **Ramda with currying and composition**: uses Ramda's pipe function to compose multiple functions together.
	* Breakdown:
		+ `R.pipe(R.pluck('counter'), R.filter(isOdd), R.map(square), R.filter(lessThanThreeDigits))(data)`
			- `R.pipe` applies a series of functions in order, passing the output of each as input to the next.
			- Each function extracts or filters data using Ramda's functions (`pluck`, `filter`, `map`).
4. **Underscore**: uses Underscore's chain method to process the data.
	* Breakdown:
		+ `_ = _.chain(data)`
			- Creates a pipeline of functions similar to Lodash, but with different syntax.
		+ `.map(item => item.counter)`
		+ `.filter(isOdd)`
		+ `.map(square)`
		+ `.filter(lessThanThreeDigits)`
		+ `.value()`

**Pros and Cons**

Each library has its strengths and weaknesses:

* **Lodash**: provides a comprehensive set of utility functions, but can be slow due to its chain method implementation.
* **Ramda**: offers functional programming principles with strong focus on composition, which can lead to more efficient code. However, it may require additional setup for developers familiar with currying or composition.
* **Underscore**: shares similarities with Lodash's chain method syntax but may have performance implications due to its caching and memoization features.

**Other Considerations**

The benchmark is likely designed to test the performance of these libraries in common data processing tasks, such as filtering and mapping. It may also be intended to showcase each library's strengths and weaknesses.

In terms of alternatives, other popular JavaScript libraries for functional programming or utility functions include:

* **Mocha**: a testing framework
* **Papa**: a JSON parsing library (not used in this benchmark)
* **Moment.js**: a date manipulation library (not used in this benchmark)

Keep in mind that the specific use case and requirements will influence the choice of library.

Related benchmarks:

Lodash vs Ramda vs Underscore 1.5.2 (version: 0)

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

Created: 5 years ago by: Guest

Jump to the latest result

Lodash

Ramda without relying on currying or composition

Ramda with currying and composition

Underscore

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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