Anti shake & throttling enhanced version

throttle

Trigger again within the time range of the timer , Do not perform , Wait for the current timer to finish , To start the next timer task .

// setTimeout Method ,
        function throttle1(fn, interval) {
    
            let flag = true;
            return function (...args) {
    
                let that = this;
                if (!flag) return;
                flag = false;
                setTimeout(() => {
    
                    fn.apply(that, args)
                    flag = true;
                }, interval);
            }
        }
//  Calculation time interval method 
        function throttle2(fn, interval) {
    
            let last = 0;
            return function (...args) {
    
                let that = this;
                let now = +new Date();
                if (now - last < interval) return;
                last = now;
                fn.apply(that, args)
            }
        }        

Shake proof

Delete the original timer every time the event is triggered , Set up a new timer , If you repeatedly trigger , Only the last timer will be executed .

 Not an immediate version 
        function debounce(fn, delay) {
    
            let timer = null;
            return function (...args) {
    
                let that = this;
                if (timer) clearTimeout(timer)
                timer = setTimeout(() => {
    
                    fn.apply(that, args)
                }, delay);
            }
        }
//  Execute version now （ When clicked, it will be called immediately , If in delay Second continuous trigger will not call again , If in delay No trigger within seconds , It will trigger again the next time you click ）
		 function debounce(fn, delay) {
    
            let timer = null;
            return function () {
    
                let that = this;
                if (timer) clearTimeout(timer);
                let callNow = !timer;
                timer = setTimeout(() => {
    
                    timer = null;
                }, delay);
                if (callNow) fn.apply(that);
            }
        }


	//  Final composite 
    /** * @desc  Function anti shake  * @param func  Objective function  * @param wait  Delay execution in milliseconds  * @param immediate true -  Execute now , false -  Delay the  */
    function debounce(func, delay, immediate) {
    
        let timer;
        return function() {
    
          let that = this,
              args = arguments;
             
          if (timer) clearTimeout(timer);
          if (immediate) {
    
            let callNow = !timer;
            timer = setTimeout(() => {
    
              timer = null;
            }, delay);
            if (callNow) func.apply(that, args);
          } else {
    
            timer  = setTimeout(() => {
    
              func.apply
            }, delay)
          }
        }
    }