Benchmark: fwef132 - MeasureThat.net

HTML Preparation code:

<script src="//cdnjs.cloudflare.com/ajax/libs/ramda/0.27.0/ramda.js"></script>
<script src="//cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.15/lodash.fp.js"></script>

AخA
 
<script src="//cdnjs.cloudflare.com/ajax/libs/ramda/0.27.0/ramda.js"></script>
<script src="//cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.15/lodash.fp.js"></script>

Script Preparation code:

var data = Array(100).fill().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;
}

​x
 
var data = Array(100).fill().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:

ramda

var result = R.pipe(
  R.map(x => x.counter),
  R.filter(isOdd),
  R.map(square),
  R.filter(lessThanThreeDigits)
)(data);

 
var result = R.pipe(  R.map(x => x.counter),  R.filter(isOdd),  R.map(square),  R.filter(lessThanThreeDigits))(data);

lo

var a = _.pick(data, 'counter')
var b = _.filter(a, isOdd)
var c = _.map(b, square)
var d = _.filter(c, lessThanThreeDigits)

 
var a = _.pick(data, 'counter')var b = _.filter(a, isOdd)var c = _.map(b, square)var d = _.filter(c, lessThanThreeDigits)

lodash fp
var result = _.flow( _.map(_.pick('counter')), _.filter(isOdd), _.map(square), _.filter(lessThanThreeDigits), )(data);
var result = _.flow(
_.map(_.pick('counter')),
_.filter(isOdd),
_.map(square),
_.filter(lessThanThreeDigits),
)(data);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
ramda
lo
lodash fp

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 80 on Mac OS X 10.15.4

View result in a separate tab

Test name	Executions per second
ramda	61000.0 Ops/sec
lo	63468.4 Ops/sec
lodash fp	14274.6 Ops/sec

Autogenerated LLM Summary (model gemma2:9b, generated 5 months ago):

This benchmark tests the performance of three different approaches to processing an array of objects in JavaScript:

Options Compared:

Ramda (ramda Test): Uses Ramda, a functional programming library known for its immutability and concise syntax. It chains together functions like map, filter, and square using R.pipe for data transformation.
Lodash (lo Test): Employs Lodash, another popular library offering utility functions for array manipulation. It uses a more imperative style with individual function calls like _.pick, _.filter, and _.map.
Lodash Flow (lodash fp Test): Similar to Ramda's approach, this uses Lodash's _.flow function to chain together transformations like _.map(_.pick('counter')), _.filter(isOdd), etc. This highlights the power of functional composition for readability and potential performance gains.

Pros/Cons:

Ramda:
- Pros: Highly readable due to its functional style, promotes immutability (data doesn't change in place), extensive set of functions for complex data manipulation.
- Cons: Can have a steeper learning curve for beginners unfamiliar with functional programming concepts, potential overhead from creating new data structures during each function call.
Lodash:
- Pros: Widely used, mature library with a vast collection of utility functions, familiar imperative syntax.
- Cons: Less emphasis on immutability, can lead to more verbose code for complex operations compared to Ramda.
Lodash Flow:
- Pros: Combines the benefits of Lodash and functional composition, improves readability for complex data transformations.
- Cons: Still requires understanding of function chaining and Lodash's syntax.

Other Considerations:

Benchmark Context: The specific tasks (filtering odd numbers, squaring values, checking if less than three digits) influence performance.
Data Size: The size of the data array significantly impacts execution time.

Alternatives:

Besides Ramda and Lodash, other options for functional programming in JavaScript include:

Immutable.js: A library focused on immutable data structures and persistent transformations.
RxJS: Reactive programming library that handles asynchronous data streams.

Let me know if you'd like to dive deeper into any specific aspect!

LLMs can make mistakes. Check important info.

This benchmark tests the performance of three different approaches to processing an array of objects in JavaScript:

**Options Compared:**

* **Ramda (`ramda` Test):** Uses Ramda, a functional programming library known for its immutability and concise syntax.  It chains together functions like `map`, `filter`, and `square` using `R.pipe` for data transformation.
* **Lodash (`lo` Test):** Employs Lodash, another popular library offering utility functions for array manipulation. It uses a more imperative style with individual function calls like `_.pick`, `_.filter`, and `_.map`. 
* **Lodash Flow (`lodash fp` Test):**  Similar to Ramda's approach, this uses Lodash's `_.flow` function to chain together transformations like `_.map(_.pick('counter'))`, `_.filter(isOdd)`, etc. This highlights the power of functional composition for readability and potential performance gains.

**Pros/Cons:**

* **Ramda:**
    *  **Pros:** Highly readable due to its functional style, promotes immutability (data doesn't change in place), extensive set of functions for complex data manipulation.
    *  **Cons:** Can have a steeper learning curve for beginners unfamiliar with functional programming concepts, potential overhead from creating new data structures during each function call.

* **Lodash:**
    *  **Pros:** Widely used, mature library with a vast collection of utility functions, familiar imperative syntax.
    *  **Cons:** Less emphasis on immutability, can lead to more verbose code for complex operations compared to Ramda.

* **Lodash Flow:**
    * **Pros:** Combines the benefits of Lodash and functional composition, improves readability for complex data transformations.
    * **Cons:** Still requires understanding of function chaining and Lodash's syntax.

**Other Considerations:**

* **Benchmark Context:** The specific tasks (filtering odd numbers, squaring values, checking if less than three digits) influence performance. 
* **Data Size:** The size of the `data` array significantly impacts execution time.

**Alternatives:**

Besides Ramda and Lodash, other options for functional programming in JavaScript include:

* **Immutable.js:** A library focused on immutable data structures and persistent transformations.
* **RxJS:** Reactive programming library that handles asynchronous data streams.

Let me know if you'd like to dive deeper into any specific aspect!

Related benchmarks:

fwef132 (version: 0)

sdf

Comparing performance of: ramda vs lo vs lodash fp

Created: 4 years ago by: Guest

Jump to the latest result