{"id":58071,"date":"2023-08-23T17:50:07","date_gmt":"2023-08-23T12:20:07","guid":{"rendered":"https:\/\/www.tothenew.com\/blog\/?p=58071"},"modified":"2023-08-31T17:56:34","modified_gmt":"2023-08-31T12:26:34","slug":"event-optimization-using-debounce","status":"publish","type":"post","link":"https:\/\/www.tothenew.com\/blog\/event-optimization-using-debounce\/","title":{"rendered":"Event optimization using debounce"},"content":{"rendered":"

What is Debounce?<\/h2>\n

Debounce is an optimization technique to reduce the frequency of repetitive function calls.<\/p>\n

It is especially suitable for cases where we have some function that can be called multiple times within a short duration, but only the latest execution result is required.<\/p>\n

There are many ways to implement it. The general concept is we take a function and attach a timer to it. Now, whenever the method gets called, the timer starts, and the code executes when the timer finishes. If it gets called again before the ongoing timer completes, the previous call is rejected (the logic will not run), and the timer starts again, repeating the process. It happens till the timer completes. Then, only the logic is executed.<\/p>\n

<\/div>\n

Let’s take an example to get more clarity.<\/strong><\/p>\n

Assume there is a search box in the UI. We want to make the search results look real-time. The code is such that for every input from the user, an API call is made to the server, and upon receiving a response, we show the result in the UI.<\/p>\n

It is a perfect scenario for debounce as we want the search to appear in real-time, but only the result of the latest input is required. In short, we can skip the in-between API calls. Let’s see how.<\/p>\n

I have created a simple app using React. Just like our example, it has a search input.<\/p>\n

<\/div>\n
\"\"<\/div>\n
<\/div>\n
<\/div>\n

We also have a search component.<\/strong><\/p>\n

\"\"<\/h1>\n

It has an input field, and on any change in the input, it calls the fetchData function. fetchData calls the API and sets the result to show in the UI.<\/p>\n

The API that I’m using is for movies. So let’s search “Dark Knight”…<\/p>\n

We have the results, but notice the number of API calls made. There are eleven API calls (one for each character).<\/p>\n

<\/div>\n

\"\"<\/h1>\n
<\/div>\n

Let’s use debounce here.<\/h3>\n

I have created a higher-order function (debounce). A higher-order function is a function that takes another function as an argument or returns a function.<\/p>\n

\"\"<\/div>\n

The debounce function takes two arguments –
\n<\/span><\/p>\n

    \n
  1. func (The function to debounce. We’ll call it the original <\/em>function<\/em>)
    \n<\/span><\/li>\n
  2. delay (time for setTimeout)<\/span><\/li>\n<\/ol>\n
    It then returns a new function. We’ll call it the debounced\u00a0function<\/em>.<\/div>\n
    This\u00a0debounced function<\/em> has access to the\u00a0timer\u00a0<\/em>variable. Whenever this\u00a0debounced function<\/em> is called, it clears the timer value, if any, and then starts a setTimeout and assigns it to the timer. When the timer completes, it calls the\u00a0original function<\/em>.<\/div>\n
    <\/div>\n
    \n

    Let’s go back to our Search component and make the necessary changes.<\/span><\/p>\n

      \n
    1. We’ll create a debounced version of the fetchData function (debouncedFetchData).<\/span><\/li>\n
    2. Whenever the input changes, call debouncedFetchData instead of fetchData.\n

      <\/span><\/li>\n<\/ol>\n<\/div>\n

      \"\"<\/h1>\n
      <\/div>\n

      Okay, now let’s try the search again.<\/p>\n

      This time, there were only four API calls compared to the eleven before.<\/p>\n

      \u00a0\"\"<\/p>\n

      \n

      Conclusion<\/h3>\n

      Event handling is an integral part of front-end development. Anytime we work with repetitive events that we can group, debounce might fit the use case perfectly. It is simple to implement yet very effective, and it can save server costs and make the application more performant.<\/p>\n

      Please refer to our blogs for more insightful content.<\/p>\n<\/div>\n

      <\/div>","protected":false},"excerpt":{"rendered":"

      What is Debounce? Debounce is an optimization technique to reduce the frequency of repetitive function calls. It is especially suitable for cases where we have some function that can be called multiple times within a short duration, but only the latest execution result is required. There are many ways to implement it. The general concept […]<\/p>\n","protected":false},"author":1613,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"iawp_total_views":5},"categories":[3429,3038,1994],"tags":[5353],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts\/58071"}],"collection":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/users\/1613"}],"replies":[{"embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/comments?post=58071"}],"version-history":[{"count":2,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts\/58071\/revisions"}],"predecessor-version":[{"id":58249,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts\/58071\/revisions\/58249"}],"wp:attachment":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/media?parent=58071"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/categories?post=58071"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/tags?post=58071"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}