Benchmark: debounce ramda vs. underscore

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/ramda/0.27.1/ramda.min.js'></script>
<script src='https://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.13.1/underscore-min.js'></script>

Script Preparation code:

var debounceR = R.curry((config, fn) => {
    const { delay, initialInstant = false } = (R.is(Number, config)
        ? { delay: config }
        : config);
    let timer = null;
    let firstCall = false;
    return (...args) => new Promise((resolve, reject) => {
        const safeCall = () => {
            try {
                resolve(fn.apply(window, args));
            }
            catch (e) {
                reject(e);
            }
        };
        if (!firstCall) {
            firstCall = true;
            if (initialInstant) {
                safeCall();
                return;
            }
        }
        if (!R.isNil(timer)) {
            clearTimeout(timer);
        }
        timer = setTimeout(safeCall, delay);
    });
});


var debounceV = (func, timeout) => {
  let timer;
  return (...args) => {
    clearTimeout(timer);
    timer = setTimeout(() => { func.apply(this, args); }, timeout);
  };
}

var handler = () => {};

Tests:

ramda
debounceR({delay: 0}, handler)
lodash
_.debounce(handler, 0)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
ramda
lodash

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark.

**Benchmark Definition JSON:**

The benchmark compares two debouncing functions: `debounceR` from Ramda and `debounceV` from vanilla JavaScript.

* `debounceR` is a higher-order function that takes an optional `initialInstant` parameter. If set, it will immediately invoke the wrapped function once when the input changes. This behavior is not present in `debounceV`.
* `debounceV` is a simple function that uses a timer to debounce the input function.

**Options being compared:**

The benchmark compares two options:

1. **Ramda's debounceR**: Debounces the input function with an optional initial instant.
2. **Vanilla JavaScript's debounceV**: Debounces the input function without an initial instant.

**Pros and Cons:**

* **debounceR (Ramda)**:
	+ Pros:
		- Supports initial instant behavior, which can be useful for certain use cases (e.g., setting a default value when no input is provided).
		- Higher-order function makes it easy to reuse the debouncing logic.
	+ Cons:
		- Adds an extra layer of complexity due to the `initialInstant` parameter and the implementation details.
		- May lead to slower performance compared to `debounceV`, as Ramda's higher-order function approach involves additional overhead.
* **debounceV (Vanilla JavaScript)**:
	+ Pros:
		- Simpler and more lightweight, with fewer lines of code.
		- Faster execution speed due to the lack of higher-order function overhead.
	+ Cons:
		- Requires manual management of timers, which can lead to more complexity and potential errors.

**Library usage:**

The benchmark uses two libraries:

1. **Ramda**: A functional programming library that provides various utility functions for tasks like debouncing. In this case, Ramda's `debounceR` function is used.
2. **Underscore.js**: A utility-first JavaScript library that provides a simple way to implement debouncing using its `debounce` function.

**Special JS feature or syntax:**

The benchmark does not explicitly use any special JavaScript features or syntax beyond the standard ES5/ES6 functionality.

**Alternative approaches:**

1. **Manual timer implementation**: Instead of using libraries like Ramda or Underscore, you could implement debouncing manually using a timer and a callback function.
2. **Other libraries**: Other libraries, such as Lodash or Moment.js, may also provide debouncing functions that can be compared in the benchmark.

In summary, the benchmark compares two approaches to debouncing: Ramda's `debounceR` with optional initial instant and vanilla JavaScript's `debounceV`. The choice between these options depends on the specific use case and performance requirements.

Related benchmarks:

debounce ramda vs. underscore (version: 0)

Comparing performance of: ramda vs lodash

Created: 4 years ago by: Guest

Jump to the latest result

ramda

lodash

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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