防抖＆节流 加强版

节流

在定时器的时间范围内再次触发，则不执行，等当前定时器完成，才能启动下一个定时器任务。

// setTimeout方法，
        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);
            }
        }
// 计算时间间隔法
        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)
            }
        }        

防抖

每次事件触发则删除原来的定时器，建立新的定时器，如果你反复触发，则只会执行最后一次的定时器。

非立即执行版本
        function debounce(fn, delay) {
    
            let timer = null;
            return function (...args) {
    
                let that = this;
                if (timer) clearTimeout(timer)
                timer = setTimeout(() => {
    
                    fn.apply(that, args)
                }, delay);
            }
        }
// 立即执行版本（点击的时候会立即调用一次，如果在delay秒内连续触发不会再次调用，如果在delay秒内没有触发，下次点击的时候会再次触发）
		 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);
            }
        }


	// 最终合成版
    /** * @desc 函数防抖 * @param func 目标函数 * @param wait 延迟执行毫秒数 * @param immediate true - 立即执行， false - 延迟执行 */
    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)
          }
        }
    }