Detailed explanation of JavaScript function throttling concepts and usage examples-JS Tutorial-php.cn

Detailed explanation of JavaScript function throttling concepts and usage examples

高洛峰

Release： 2016-12-29 10:04:47

Original

1337 people have browsed it

The examples in this article describe the concept and usage of JavaScript function throttling. I share it with you for your reference. The details are as follows:

Recently when I was making a web page, I had a need to change the size of some page elements when the browser window changed, so I naturally thought of window resize. Event, so that’s what I wrote

<!DOCTYPE html>
<html>
<head>
  <title>Throttle</title>
</head>
<body>
  <script type="text/javascript">
    n=0;
    function resizehandler(){
      console.log(new Date().getTime());
      console.log(++n);
    }
    window.onresize=resizehandler;
  </script>
</body>
</html>

Copy after login

The function was implemented, but when I changed the size of the browser window by dragging, I looked at the console

Yes, it’s simple A drag and drop caused my resizeHandler() method to be executed 52 times. This is not the effect I want at all. In fact, the code of my resizeHandler() method is very complicated, and I even use ajax to send a request to the server. If it were a simple one Changing the window size requires calling it 52 times, which is okay.

Function throttling

In fact, my original intention is just to make some adjustments to the page after the window is resized, and the resize event of the window is not in It is triggered after resize is completed. I don't know the specific frequency, but it is called continuously until the window size no longer changes. In fact, a similar mechanism is mousemove, which is triggered repeatedly in a short period of time.

In "JavaScript Advanced Programming", there is a special function throttling to deal with this problem

function throttle(method,context){
  clearTimeout(method.tId);
  method.tId=setTimeout(function(){
    method.call(context);
  },500);
}

Copy after login

The principle is very simple. Use a timer to delay function execution by 500 milliseconds. If within 500 milliseconds, If the function is called again, the previous call will be deleted, and this call will be executed 500 milliseconds later, and so on. In this way, I can change the code I just made to

<script type="text/javascript">
n=0;
function resizehandler(){
  console.log(new Date().getTime());
  console.log(++n);
}
function throttle(method,context){
  clearTimeout(method.tId);
  method.tId=setTimeout(function(){
    method.call(context);
  },500);
}
window.onresize=function(){
  throttle(resizehandler,window);
};
</script>

Copy after login

and try dragging it. Sure enough, it is only executed once.

Another approach

There is also a function throttling solution on the Internet , this is how it is done

function throttle(method,delay){
  var timer=null;
  return function(){
    var context=this, args=arguments;
    clearTimeout(timer);
    timer=setTimeout(function(){
      method.apply(context,args);
    },delay);
  }
}

Copy after login

Try calling it, the same effect

<script type="text/javascript">
n=0;
function resizehandler(){
  console.log(new Date().getTime());
  console.log(++n);
}
function throttle(method,delay){
  var timer=null;
  return function(){
    var context=this, args=arguments;
    clearTimeout(timer);
    timer=setTimeout(function(){
      method.apply(context,args);
    },delay);
  }
}
window.onresize=throttle(resizehandler,500);//因为返回函数句柄，不用包装函数了
</script>

Copy after login

Detailed explanation of JavaScript function throttling concepts and usage examples

Comparison

Both methods are used Instead of setTimeout, the difference is that the function added by the second method delays the execution time. This function is easily available in the first solution, just by adding a parameter.

But the first solution sets tId as a variable of the function and saves it, while the second solution creates a closure to store it. Personally, I don't think the difference is big. I really like the first one, it's simple and efficient.

New requirements

One day I made something similar, just like the automatic prompt for input on the Baidu homepage. I bound the keyup event to the text, every time the keyboard bounces up. It prompts automatically, but I don’t want to prompt so frequently, so I used the above method, but it’s a tragedy. It only prompts after stopping input for 500 milliseconds. There is no prompt at all during the input process. I looked at the code and found that it is not true. As long as the user can touch type and press the keyboard within 500 milliseconds, the prompt function will be continuously delayed, so that the prompt will only occur when it stops, which is meaningless.

Can it be executed at a fixed interval based on function throttling?

Small changes

After searching on the Internet, we can make some changes based on the second way of writing (the first way of expanding multiple variables for functions feels a bit bad) and add a parameter as Fixed intervals must be executed

function throttle(method,delay,duration){
  var timer=null, begin=new Date();
  return function(){
    var context=this, args=arguments, current=new Date();;
    clearTimeout(timer);
    if(current-begin>=duration){
       method.apply(context,args);
       begin=current;
    }else{
      timer=setTimeout(function(){
        method.apply(context,args);
      },delay);
    }
  }
}

Copy after login

In this way, each time we judge how long the interval is, if it exceeds the set time, it will be executed immediately. Try the effect with the example just now

window.onresize=throttle(resizehandler,100,200);

Copy after login

Detailed explanation of JavaScript function throttling concepts and usage examples

Sure enough, it is neither executed frequently nor executed at the end

I hope this article will be helpful to everyone in JavaScript programming.

For more detailed explanations of JavaScript function throttling concepts and usage examples, please pay attention to the PHP Chinese website!