When writing applications in javascript, we rarely consider performance, however as the user base or application usage increases performance becomes a huge bottleneck for growth. One powerful technique to manage the frequency of function execution is debouncing. In this post, we’ll explore what debouncing is, why it’s useful, and how to implement it with examples from both a console application and a web application.
What is Debouncing?
Debouncing is a technique used to ensure that a function is only executed after a certain amount of time has passed since it was last invoked. This is particularly useful in scenarios where an event fires multiple times in quick succession, like keystrokes, window resizing, or scroll events. By debouncing, we can limit the number of times the function is called, improving performance and user experience.
Why Use Debouncing?
Imagine a search input field that sends a request to a server every time a user types a character. Without debouncing, a request would be sent for every keystroke, potentially overwhelming the server with unnecessary requests. Debouncing ensures that the request is only sent after the user has stopped typing for a specified period, reducing the number of requests and improving efficiency.
Example 1: Console application
Let’s start with a simple example in a console application using Node.js. We’ll create a debounced function that logs a message only after the user stops typing for 1 second.
First, install the ‘readline‘ module if you haven’t already:
npm install @types/node
Here’s the TypeScript code:
import * as readline from 'readline';
// Declare debounce type separately
type Debounce = <T extends (...args: any[]) => void>(func: T, wait: number) => (this: unknown, ...args: Parameters<T>) => void;
const debounce: Debounce = (func, wait) => {
let timeout: NodeJS.Timeout | undefined;
return function (this: unknown, ...args: Parameters<typeof func>) {
const context = this;
if (timeout) clearTimeout(timeout);
timeout = setTimeout(() => func.apply(context, args), wait);
};
}
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout
});
const handleInput = debounce((input: string) => {
console.log('Executing command:', input.trim());
}, 1000);
console.log('Type a command and press Enter:');
rl.on('line', handleInput);
In the above example the the ‘handleInput’ function gets called only after 1 second after the user stops typing, allowing the application to reduce the unnecessary executions each time the user is typing.
Now, let’s look at an example in a web application. We’ll debounce a function that handles input events on a search field, ensuring the search function is only called after the user stops typing for 300 milliseconds.
HTML:
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>Debouncing Example</title> </head> <body> <input type="text" id="searchInput" placeholder="Type to search..." /> <script src="app.js"></script> </body> </html>
JavaScript (app.js):
function debounce(func, wait) {
let timeout;
return function (...args) {
const context = this;
clearTimeout(timeout);
timeout = setTimeout(() => func.apply(context, args), wait);
};
}
const handleInput = debounce((event) => {
console.log('Search query:', event.target.value);
}, 300);
document.getElementById('searchInput').addEventListener('input', handleInput);
Conclusion:
Debouncing is a simple yet powerful technique to control the execution frequency of functions in JavaScript. By applying debouncing in both console and web applications, you can significantly improve performance and user experience. Whether you’re managing user input, scroll events, or resize events, debouncing ensures that your functions are executed efficiently and only when necessary. In my next article I will go into debouncing in a react application using useCallback hook and lodash ‘debounce’
For complete source – https://github.com/IndikaMaligaspe/advance-javascrips/tree/master/topics/performance-optimization