前言

前面已经对防抖和节流有了介绍，这篇主要看lodash是如何将防抖和节流合并成一个函数的。

初衷是深入lodash，学习它内部的好代码并应用，同时也加深节流防抖的理解。这里会先从防抖开始一步步往后，由简入繁，直到最后实现整个函数。

这里纯粹自己的理解，以及看了很多篇优质文章，希望能加深对节流防抖的理解，如果有不同意见或者看法，欢迎大家评论。

原理

前面虽然已经介绍过防抖和节流原理，这里为了加深印象，再搬过来。

防抖的原理：在wait时间内，持续触发某个事件。第一种情况：如果某个事件触发wait秒内又触发了该事件，就应该以新的事件wait等待时间为准，wait秒后再执行此事件；第二种情况：如果某个事件触发wait秒后，未再触发该事件，则在wait秒后直接执行该事件。

通俗点说：定义wait=3000，持续点击按钮，前后点击间隔都在3秒内，则在最后一次点击按钮后，等待3秒再执行func方法。如果点击完按钮，3秒后未再次点击按钮，则3秒后直接执行func方法。

节流的原理：持续触发某事件，每隔一段时间，只执行一次。

通俗点说，3 秒内多次调用函数，但是在 3 秒间隔内只执行一次，第一次执行后 3 秒 无视后面所有的函数调用请求，也不会延长时间间隔。3 秒间隔结束后则开始执行新的函数调用请求，然后在这新的 3 秒内依旧无视后面所有的函数调用请求，以此类推。

简单来说：每隔单位时间（ 3 秒），只执行一次。

代码分析

一、引入代码部分

首先看源码最前方的引入。

  1. import isObject from './isObject.js'
  2. import root from './.internal/root.js'

isObject方法，直接拿出来，

  1. function isObject(value) {
  2.     const type = typeof value;
  3.     return value != null && (type === "object" || type === "function");
  4. }

root的引入主要是window。为了引出window.requestAnimationFrame。

二、requestAnimationFrame代码

window.requestAnimationFrame()告诉浏览器希望执行动画并请求浏览器在下一次重绘之前调用指定的函数来更新动画，差不多 16ms 执行一次。

lodash这里使用requestAnimationFrame，主要是用户使用debounce函数未设置wait的情况下使用requestAnimationFrame。

  1. const useRAF = (!wait && wait !== 0 && typeof window.requestAnimationFrame === 'function')
  2. function startTimer(pendingFunc, wait) {
  3.     if (useRAF) {
  4.         window.cancelAnimationFrame(timerId)
  5.         return window.requestAnimationFrame(pendingFunc)
  6.     }
  7.     return setTimeout(pendingFunc, wait)
  8. }
  10. function cancelTimer(id) {
  11.     if (useRAF) {
  12.         return window.cancelAnimationFrame(id)
  13.     }
  14.     clearTimeout(id)
  15. }

由代码const useRAF = (!wait && wait !== 0 && typeof window.requestAnimationFrame === 'function')不难看出,函数未传入wait并且window.cancelAnimationFrame函数存在这两种情况下操作window.requestAnimationFrame

三、由简入繁输出防抖函数

  • 首先，我们来看下lodash debounce API
    这部分参数内容就直接摘抄在下方：
    • func (Function): 要防抖动的函数。
    • [wait=0] (number): 需要延迟的毫秒数。
    • [options=] (Object): 选项对象。
    • [options.leading=false] (boolean): 指定在延迟开始前调用。
    • [options.maxWait] (number): 设置 func 允许被延迟的最大值。
    • [options.trailing=true] (boolean): 指定在延迟结束后调用。
  • 然后，我们一般防抖函数，需要的参数是：func、wait、immediate这三个参数，对应lodash，我们需要拿出这四个部分：
    • func (Function): 要防抖动的函数。
    • [wait=0] (number): 需要延迟的毫秒数。
    • [options=] (Object): 选项对象。
    • [options.leading=false] (boolean): 指定在延迟开始前调用。
  • 接着，按照这个形式，先写出最简防抖方法。也就是这两部分参数的代码
    • func (Function): 要防抖动的函数。
    • [wait=0] (number): 需要延迟的毫秒数。
  1. // 代码1
  2. function debounce(func, wait) {
  3.     let timerId, // setTimeout 生成的定时器句柄
  4.       lastThis, // 保存上一次 this
  5.       lastArgs, // 保存上一次执行 debounced 的 arguments
  6.       result; // 函数 func 执行后的返回值，多次触发但未满足执行 func 条件时，返回 result
  8.     wait = +wait || 0; // 等待时间
  10.     // 没传 wait 时调用 window.requestAnimationFrame()
  11.     const useRAF =
  12.       !wait &&
  13.       wait !== 0 &&
  14.       typeof window.requestAnimationFrame === "function";
  16.     // 取消debounce
  17.     function cancel() {
  18.       if (timerId !== undefined) {
  19.         cancelTimer(timerId);
  20.       }
  21.       lastArgs = lastThis = timerId = result = undefined;
  22.     }
  24.     // 开启定时器
  25.     // 1.未传wait时使用requestAnimationFrame
  26.     // 2.直接使用定时器
  27.     function startTimer(pendingFunc, wait) {
  28.       if (useRAF) {
  29.         window.cancelAnimationFrame(timerId);
  30.         return window.requestAnimationFrame(pendingFunc);
  31.       }
  32.       return setTimeout(pendingFunc, wait);
  33.     }
  35.     // 定时器回调函数，表示定时结束后的操作
  36.     function timerExpired(wait) {
  37.       const time = Date.now();
  38.       timerId = startTimer(invokeFunc, wait);
  39.     }
  41.     // 取消定时器
  42.     function cancelTimer(id) {
  43.       if (useRAF) {
  44.         return window.cancelAnimationFrame(id);
  45.       }
  46.       clearTimeout(id);
  47.       timerId = undefined;
  48.     }
  50.     // 执行函数,并将原函数的返回值result输出
  51.     function invokeFunc() {
  52.       const args = lastArgs;
  53.       const thisArg = lastThis;
  55.       lastArgs = lastThis = undefined; // 清空当前函数指向的this,argumnents
  56.       result = func.apply(thisArg, args); // 绑定当前函数指向的this,argumnents
  57.       return result;
  58.     }
  60.     const debounced = function (...args) {
  61.       const time = Date.now(); // 获取当前时间
  63.       lastArgs = args;
  64.       lastThis = this;
  66.       if (timerId) {
  67.         cancelTimer(timerId);
  68.       }
  69.       if (timerId === undefined) {
  70.         timerId = startTimer(timerExpired, wait);
  71.       }
  72.     };
  74.     debounced.cancel = cancel;
  75.     return debounced;
  76. }
  1.     看上述代码：
  2.     1. 多了未传wait情况，使用`window.requestAnimationFrame`。  
  3.     2. 将定时器，绑定this，arguments、result和取消定时器等分函数拿了出来。
  • 再者，将options的leading加上。也就是immediate立即执行，组成完整的防抖函数。引入参数是下面这部分
    • func (Function): 要防抖动的函数。
    • [wait=0] (number): 需要延迟的毫秒数。
    • [options=] (Object): 选项对象。
    • [options.leading=false] (boolean): 指定在延迟开始前调用。
  1. // 代码二
  3. function debounce(func, wait, options) {
  4.     let timerId, // setTimeout 生成的定时器句柄
  5.       lastThis, // 保存上一次 this
  6.       lastArgs, // 保存上一次执行 debounced 的 arguments
  7.       result, // 函数 func 执行后的返回值，多次触发但未满足执行 func 条件时，返回 result
  8.       lastCallTime; // 上一次调用 debounce 的时间
  10.     let leading = false; // 判断是否立即执行，默认false
  12.     wait = +wait || 0;
  14.     // 从options中获取是否立即执行
  15.     if (isObject(options)) {
  16.       leading = !!options.leading;
  17.     }
  18.     // 没传 wait 时调用 window.requestAnimationFrame()
  19.     const useRAF =
  20.       !wait &&
  21.       wait !== 0 &&
  22.       typeof window.requestAnimationFrame === "function";
  24.     // 取消debounce
  25.     function cancel() {
  26.       if (timerId !== undefined) {
  27.         cancelTimer(timerId);
  28.       }
  29.       lastArgs = lastThis = timerId = result = lastCallTime = undefined;
  30.     }
  32.     // 开启定时器
  33.     function startTimer(pendingFunc, wait) {
  34.       if (useRAF) {
  35.         window.cancelAnimationFrame(timerId);
  36.         return window.requestAnimationFrame(pendingFunc);
  37.       }
  38.       return setTimeout(pendingFunc, wait);
  39.     }
  41.     // 定时器回调函数，表示定时结束后的操作
  42.     function timerExpired(wait) {
  43.       const time = Date.now();
  44.       // 1、是否需要执行
  45.       // 执行事件结束后的那次回调，否则重启定时器
  46.       if (shouldInvoke(time)) {
  47.         return trailingEdge(time);
  48.       }
  49.       // 2、否则 计算剩余等待时间，重启定时器，保证下一次时延的末尾触发
  50.       timerId = startTimer(timerExpired, wait);
  51.     }
  53.     // 这里时触发后仍调用函数
  54.     function trailingEdge(time) {
  55.       timerId = undefined;
  57.       // 只有当我们有 `lastArgs` 时才调用，这意味着`func'已经被调用过一次。
  58.       if (lastArgs) {
  59.         return invokeFunc(time);
  60.       }
  61.       lastArgs = lastThis = undefined;
  62.       return result;
  63.     }
  65.     // 取消定时器
  66.     function cancelTimer(id) {
  67.       if (useRAF) {
  68.         return window.cancelAnimationFrame(id);
  69.       }
  70.       clearTimeout(id);
  71.     }
  73.     function invokeFunc(time) {
  74.       const args = lastArgs;
  75.       const thisArg = lastThis;
  77.       lastArgs = lastThis = undefined; // 清空当前函数指向的this,argumnents
  78.       result = func.apply(thisArg, args); // 绑定当前函数指向的this,argumnents
  79.       return result;
  80.     }
  81.     // 判断此时是否立即执行 func 函数
  82.     // lastCallTime === undefined 第一次调用时
  83.     // timeSinceLastCall >= wait 超过超时时间 wait，处理事件结束后的那次回调
  84.     // timeSinceLastCall < 0 当前时间 - 上次调用时间小于 0，即更改了系统时间
  85.     function shouldInvoke(time) {
  86.       const timeSinceLastCall = time - lastCallTime;
  87.       return (
  88.         lastCallTime === undefined ||
  89.         timeSinceLastCall >= wait ||
  90.         timeSinceLastCall < 0
  91.       );
  92.     }
  94.     // 立即执行函数
  95.     function leadingEdge(time) {
  96.       // 1、开启定时器，为了事件结束后的那次回调
  97.       timerId = startTimer(timerExpired, wait);
  98.       // 1、如果配置了 leading 执行传入函数 func
  99.       // leading 来源自 !!options.leading
  100.       return leading ? invokeFunc(time) : result;
  101.     }
  103.     const debounced = function (...args) {
  104.       const time = Date.now(); // 获取当前时间
  105.       const isInvoking = shouldInvoke(time); // 判断此时是否立即执行 func 函数
  107.       lastArgs = args;
  108.       lastThis = this;
  109.       lastCallTime = time;
  111.       if (isInvoking) {
  112.         // 判断是否立即执行
  113.         if (timerId === undefined) {
  114.           return leadingEdge(lastCallTime);
  115.         }
  116.       }
  117.       if (timerId === undefined) {
  118.         timerId = startTimer(timerExpired, wait);
  119.       }
  120.       return result;
  121.     };
  123.     debounced.cancel = cancel;
  124.     return debounced;
  125. }
  1.     上述代码：
  2.         1. 增加trailingEdge、trailingEdge以及invokeFunc函数
  3.         2. options目前只支持传入leading参数，也就是immediate。
  • 再往后，我们将options中的trailing加上，也就是这四部分
    • func (Function): 要防抖动的函数。
    • [wait=0] (number): 需要延迟的毫秒数。
    • [options=] (Object): 选项对象。
    • [options.leading=false] (boolean): 指定在延迟开始前调用。
    • [options.trailing=true] (boolean): 指定在延迟结束后调用。
  1. function debounce(func, wait, options) {
  2.     let timerId, // setTimeout 生成的定时器句柄
  3.       lastThis, // 保存上一次 this
  4.       lastArgs, // 保存上一次执行 debounced 的 arguments
  5.       result, // 函数 func 执行后的返回值，多次触发但未满足执行 func 条件时，返回 result
  6.       lastCallTime; // 上一次调用 debounce 的时间
  8.     let leading = false; // 判断是否立即执行，默认false
  9.     let trailing = true; // 是否响应事件结束后的那次回调，即最后一次触发，false 时忽略,默认为true
  11.     wait = +wait || 0;
  13.     // 从options中获取是否立即执行
  14.     if (isObject(options)) {
  15.       leading = !!options.leading;
  16.       trailing = "trailing" in options ? !!options.trailing : trailing;
  17.     }
  18.     // 没传 wait 时调用 window.requestAnimationFrame()
  19.     const useRAF =
  20.       !wait &&
  21.       wait !== 0 &&
  22.       typeof window.requestAnimationFrame === "function";
  24.     // 取消debounce
  25.     function cancel() {
  26.       if (timerId !== undefined) {
  27.         cancelTimer(timerId);
  28.       }
  29.       lastArgs = lastThis = timerId = result = lastCallTime = undefined;
  30.     }
  32.     // 开启定时器
  33.     function startTimer(pendingFunc, wait) {
  34.       if (useRAF) {
  35.         window.cancelAnimationFrame(timerId);
  36.         return window.requestAnimationFrame(pendingFunc);
  37.       }
  38.       return setTimeout(pendingFunc, wait);
  39.     }
  41.     // 定时器回调函数，表示定时结束后的操作
  42.     function timerExpired(wait) {
  43.       const time = Date.now();
  44.       // 1、是否需要执行
  45.       // 执行事件结束后的那次回调，否则重启定时器
  46.       if (shouldInvoke(time)) {
  47.         return trailingEdge(time);
  48.       }
  49.       // 2、否则 计算剩余等待时间，重启定时器，保证下一次时延的末尾触发
  50.       timerId = startTimer(timerExpired, remainingWait(time));
  51.     }
  53.     function remainingWait(time) {
  54.       const timeSinceLastCall = time - lastCallTime;
  55.       const timeWaiting = wait - timeSinceLastCall;
  57.       return timeWaiting;
  58.     }
  60.     // 这里时触发后仍调用函数
  61.     function trailingEdge(time) {
  62.       timerId = undefined;
  64.       // 这意味着`func'已经被调用过一次。
  65.       if (trailing && lastArgs) {
  66.         return invokeFunc(time);
  67.       }
  68.       lastArgs = lastThis = undefined;
  69.       return result;
  70.     }
  72.     // 取消定时器
  73.     function cancelTimer(id) {
  74.       if (useRAF) {
  75.         return window.cancelAnimationFrame(id);
  76.       }
  77.       clearTimeout(id);
  78.     }
  80.     function invokeFunc(time) {
  81.       const args = lastArgs;
  82.       const thisArg = lastThis;
  83.       lastArgs = lastThis = undefined; // 清空当前函数指向的this,argumnents
  84.       result = func.apply(thisArg, args); // 绑定当前函数指向的this,argumnents
  85.       return result;
  86.     }
  87.     // 判断此时是否立即执行 func 函数
  88.     // lastCallTime === undefined 第一次调用时
  89.     // timeSinceLastCall >= wait 超过超时时间 wait，处理事件结束后的那次回调
  90.     // timeSinceLastCall < 0 当前时间 - 上次调用时间小于 0，即更改了系统时间
  91.     function shouldInvoke(time) {
  92.       const timeSinceLastCall = time - lastCallTime;
  93.       return (
  94.         lastCallTime === undefined ||
  95.         timeSinceLastCall >= wait ||
  96.         timeSinceLastCall < 0
  97.       );
  98.     }
  100.     // 立即执行函数
  101.     function leadingEdge(time) {
  102.       // 1、开启定时器，为了事件结束后的那次回调
  103.       timerId = startTimer(timerExpired, wait);
  104.       // 1、如果配置了 leading 执行传入函数 func
  105.       // leading 来源自 !!options.leading
  106.       return leading ? invokeFunc(time) : result;
  107.     }
  109.     const debounced = function (...args) {
  110.       const time = Date.now(); // 获取当前时间
  111.       const isInvoking = shouldInvoke(time); // 判断此时是否立即执行 func 函数
  113.       lastArgs = args;
  114.       lastThis = this;
  115.       lastCallTime = time;
  117.       if (isInvoking) {
  118.         // 判断是否立即执行
  119.         if (timerId === undefined) {
  120.           return leadingEdge(lastCallTime);
  121.         }
  122.       }
  123.       if (timerId === undefined) {
  124.         timerId = startTimer(timerExpired, wait);
  125.       }
  126.       return result;
  127.     };
  129.     debounced.cancel = cancel;
  130.     return debounced;
  131. }
  1.     上述代码：
  2.         1.leading和trailing不能同时为false。

其实可以在代码中加上判断同时为false时，默认wait=0，直接执行window.requestAnimationFrame部分,而不是定时器。

  • 最后结合maxWait,也就是将防抖和节流合并的关键。
    • func (Function): 要防抖动的函数。
    • [wait=0] (number): 需要延迟的毫秒数。
    • [options=] (Object): 选项对象。
    • [options.leading=false] (boolean): 指定在延迟开始前调用。
    • [options.maxWait] (number): 设置 func 允许被延迟的最大值。
    • [options.trailing=true] (boolean): 指定在延迟结束后调用。

首先，我们可以先来看lodash throttle部分源码:

  1. import debounce from './debounce.js'
  2. import isObject from './isObject.js
  3. function throttle(func, wait, options) {
  4.   let leading = true
  5.   let trailing = true
  7.   if (typeof func !== 'function') {
  8.     throw new TypeError('Expected a function')
  9.   }
  10.   if (isObject(options)) {
  11.     leading = 'leading' in options ? !!options.leading : leading
  12.     trailing = 'trailing' in options ? !!options.trailing : trailing
  13.   }
  14.   return debounce(func, wait, {
  15.     leading,
  16.     trailing,
  17.     'maxWait': wait
  18.   })
  19. }
  21. export default throttle

其实就是将wait传入了debounce函数的**option.maxWait**中。所以最后，我们只需要将之前的代码加上maxWait参数部分。

  1. function debounce(func, wait, options) {
  2.     let timerId, // setTimeout 生成的定时器句柄
  3.       lastThis, // 保存上一次 this
  4.       lastArgs, // 保存上一次执行 debounced 的 arguments
  5.       result, // 函数 func 执行后的返回值，多次触发但未满足执行 func 条件时，返回 result
  6.       lastCallTime,
  7.       maxWait; // 上一次调用 debounce 的时间
  9.     let leading = false; // 判断是否立即执行，默认false
  10.     let trailing = true; // 是否响应事件结束后的那次回调，即最后一次触发，false 时忽略,默认为true
  12.     /**
  13.      * 节流部分参数
  14.      **/
  15.     let lastInvokeTime = 0; // 上一次执行 func 的时间，配合 maxWait 多用于节流相关
  16.     let maxing = false; // 是否有最大等待时间，配合 maxWait 多用于节流相关
  18.     wait = +wait || 0;
  20.     // 从options中获取是否立即执行
  21.     if (isObject(options)) {
  22.       leading = !!options.leading;
  23.       trailing = "trailing" in options ? !!options.trailing : trailing;
  25.       /**
  26.        * 节流部分参数
  27.        **/
  28.       maxing = "maxWait" in options; // options 中是否有 maxWait 属性，节流函数预留
  29.       maxWait = maxing ? Math.max(+options.maxWait || 0, wait) : maxWait; // maxWait 为设置的 maxWait 和 wait 中最大的
  30.       // 如果 maxWait < wait，那 maxWait 就没有意义了
  31.     }
  33.     // 没传 wait 时调用 window.requestAnimationFrame()
  34.     const useRAF = !wait && wait !== 0 && typeof window.requestAnimationFrame === "function";
  36.     // 取消debounce
  37.     function cancel() {
  38.       if (timerId !== undefined) {
  39.         cancelTimer(timerId);
  40.       }
  41.       lastInvokeTime = 0;
  42.       leading = false;
  43.       maxing = false;
  44.       trailing = true;
  45.       lastArgs = lastThis = timerId = result = lastCallTime = maxWait = undefined;
  46.     }
  48.     // 开启定时器
  49.     function startTimer(pendingFunc, wait) {
  50.       if (useRAF) {
  51.         window.cancelAnimationFrame(timerId);
  52.         return window.requestAnimationFrame(pendingFunc);
  53.       }
  54.       return setTimeout(pendingFunc, wait);
  55.     }
  57.     // 定时器回调函数，表示定时结束后的操作
  58.     function timerExpired(wait) {
  59.       const time = Date.now();
  60.       // 1、是否需要执行
  61.       // 执行事件结束后的那次回调，否则重启定时器
  62.       if (shouldInvoke(time)) {
  63.         return trailingEdge(time);
  64.       }
  65.       // 2、否则 计算剩余等待时间，重启定时器，保证下一次时延的末尾触发
  66.       timerId = startTimer(timerExpired, remainingWait(time));
  67.     }
  69.     // 计算仍需等待的时间
  70.     function remainingWait(time) {
  71.       // 当前时间距离上一次调用 debounce 的时间差
  72.       const timeSinceLastCall = time - lastCallTime;
  73.       // 当前时间距离上一次执行 func 的时间差
  74.       const timeSinceLastInvoke = time - lastInvokeTime;
  75.       // 剩余等待时间
  76.       const timeWaiting = wait - timeSinceLastCall;
  78.       // 是否设置了最大等待时间
  79.       // 是（节流）：返回「剩余等待时间」和「距上次执行 func 的剩余等待时间」中的最小值
  80.       // 否：返回剩余等待时间
  81.       return maxing
  82.         ? Math.min(timeWaiting, maxWait - timeSinceLastInvoke)
  83.         : timeWaiting;
  84.     }
  86.     // 这里时触发后仍调用函数
  87.     function trailingEdge(time) {
  88.       timerId = undefined;
  90.       // 这意味着`func'已经被调用过一次。
  91.       if (trailing && lastArgs) {
  92.         return invokeFunc(time);
  93.       }
  94.       lastArgs = lastThis = undefined;
  95.       return result;
  96.     }
  98.     // 取消定时器
  99.     function cancelTimer(id) {
  100.       if (useRAF) {
  101.         return window.cancelAnimationFrame(id);
  102.       }
  103.       clearTimeout(id);
  104.     }
  106.     function invokeFunc(time) {
  107.       const args = lastArgs;
  108.       const thisArg = lastThis;
  109.       lastArgs = lastThis = undefined; // 清空当前函数指向的this,argumnents
  111.       lastInvokeTime = time;
  112.       result = func.apply(thisArg, args); // 绑定当前函数指向的this,argumnents
  113.       return result;
  114.     }
  115.     // 判断此时是否立即执行 func 函数
  116.     // lastCallTime === undefined 第一次调用时
  117.     // timeSinceLastCall >= wait 超过超时时间 wait，处理事件结束后的那次回调
  118.     // timeSinceLastCall < 0 当前时间 - 上次调用时间小于 0，即更改了系统时间
  119.     // maxing && timeSinceLastInvoke >= maxWait 超过最大等待时间
  120.     function shouldInvoke(time) {
  121.       // 当前时间距离上一次调用 debounce 的时间差
  122.       const timeSinceLastCall = time - lastCallTime;
  123.       // 当前时间距离上一次执行 func 的时间差
  124.       const timeSinceLastInvoke = time - lastInvokeTime;
  126.       // 上述 4 种情况返回 true
  127.       return (
  128.         lastCallTime === undefined ||
  129.         timeSinceLastCall >= wait ||
  130.         timeSinceLastCall < 0 ||
  131.         (maxing && timeSinceLastInvoke >= maxWait)
  132.       );
  133.     }
  135.     // 立即执行函数
  136.     function leadingEdge(time) {
  137.       // 1、设置上一次执行 func 的时间
  138.       lastInvokeTime = time;
  139.       // 2、开启定时器，为了事件结束后的那次回调
  140.       timerId = startTimer(timerExpired, wait);
  141.       // 3、如果配置了 leading 执行传入函数 func
  142.       // leading 来源自 !!options.leading
  143.       return leading ? invokeFunc(time) : result;
  144.     }
  146.     const debounced = function (...args) {
  147.       const time = Date.now(); // 获取当前时间
  148.       const isInvoking = shouldInvoke(time); // 判断此时是否立即执行 func 函数
  150.       lastArgs = args;
  151.       lastThis = this;
  152.       lastCallTime = time;
  154.       if (isInvoking) {
  155.         // 判断是否立即执行
  156.         if (timerId === undefined) {
  157.           return leadingEdge(lastCallTime);
  158.         }
  159.         // 如果设置了最大等待时间，则立即执行 func
  160.         // 1、开启定时器，到时间后触发 trailingEdge 这个函数。
  161.         // 2、执行 func，并返回结果
  162.         if (maxing) {
  163.           // 循环定时器中处理调用
  164.           timerId = startTimer(timerExpired, wait);
  165.           return invokeFunc(lastCallTime);
  166.         }
  167.       }
  168.       if (timerId === undefined) {
  169.         timerId = startTimer(timerExpired, wait);
  170.       }
  171.       return result;
  172.     };
  174.     debounced.cancel = cancel;
  175.     return debounced;
  176. }
  1. 上述代码：
  2.     尽管代码有点长，但是实际上只是增加了maxWait。

下面我们分析下maxWait新增的那部分代码。

分析maxWait新增部分

  1. // 1.定义变量
  2. let maxWait; // 上一次调用 debounce 的时间
  3. let lastInvokeTime = 0; // 上一次执行 func 的时间，配合 maxWait 多用于节流相关
  4. let maxing = false; // 是否有最大等待时间，配合 maxWait 多用于节流相关
  7. // 2.从options中取出maxWait
  8. if (isObject(options)) {
  9.   maxing = "maxWait" in options; // options 中是否有 maxWait 属性，节流函数预留
  10.   maxWait = maxing ? Math.max(+options.maxWait || 0, wait) : maxWait; // maxWait 为设置的 maxWait 和 wait 中最大的
  11.   // 如果 maxWait < wait，那 maxWait 就没有意义了
  12. }
  14. // 3.计算仍需等待的时间
  15. function remainingWait(time) {
  16.   // 当前时间距离上一次调用 debounce 的时间差
  17.   const timeSinceLastCall = time - lastCallTime;
  18.   // 当前时间距离上一次执行 func 的时间差
  19.   const timeSinceLastInvoke = time - lastInvokeTime;
  20.   // 剩余等待时间
  21.   const timeWaiting = wait - timeSinceLastCall;
  23.   // 是否设置了最大等待时间
  24.   // 是（节流）：返回「剩余等待时间」和「距上次执行 func 的剩余等待时间」中的最小值
  25.   // 否：返回剩余等待时间
  26.   return maxing
  27.     ? Math.min(timeWaiting, maxWait - timeSinceLastInvoke)
  28.     : timeWaiting;
  29. }
  31. // 4.判断是否立即执行
  32. function shouldInvoke(time) {
  33.   // 当前时间距离上一次调用 debounce 的时间差
  34.   const timeSinceLastCall = time - lastCallTime;
  35.   // 当前时间距离上一次执行 func 的时间差
  36.   const timeSinceLastInvoke = time - lastInvokeTime;
  38.   // 上述 4 种情况返回 true
  39.   return (
  40.     lastCallTime === undefined ||
  41.     timeSinceLastCall >= wait ||
  42.     timeSinceLastCall < 0 ||
  43.     (maxing && timeSinceLastInvoke >= maxWait)
  44.   );
  45. }
  47. // 5.有maxing时，应该如何处理函数
  48. if (isInvoking) {
  49.     // 判断是否立即执行
  50.     if (timerId === undefined) {
  51.       return leadingEdge(lastCallTime);
  52.     }
  53.     // 如果设置了最大等待时间，则立即执行 func
  54.     // 1、开启定时器，到时间后触发 trailingEdge 这个函数。
  55.     // 2、执行 func，并返回结果
  56.     if (maxing) {
  57.       // 循环定时器中处理调用
  58.       timerId = startTimer(timerExpired, wait);
  59.       return invokeFunc(lastCallTime);
  60.     }
  61. }

1.新增变量就不多说了。

2.从options中取出**maxWait**:

  1. // 2.从options中取出maxWait
  2. if (isObject(options)) {
  3.   maxing = "maxWait" in options; // options 中是否有 maxWait 属性，节流函数预留
  4.   maxWait = maxing ? Math.max(+options.maxWait || 0, wait) : maxWait; // maxWait 为设置的 maxWait 和 wait 中最大的
  5.   // 如果 maxWait < wait，那 maxWait 就没有意义了
  6. }
  • 1.这里主要是将maxing,判断是否传了maxWait参数。
  • 2.如果未传则maxWait还是为初始定义的undefined。
  • 3.如果传入了maxWait，则重新赋值Math.max(+options.maxWait || 0, wait)。这里主要就是取maxWait和wait中的大值。

3.计算仍需等待的时间

  1. return maxing
  2.     ? Math.min(timeWaiting, maxWait - timeSinceLastInvoke)
  3.     : timeWaiting;

首先判断是否节流（maxing）：

  1. 是=>取「剩余等待时间」和「距上次执行 func 的剩余等待时间」中的最小值。
  2. 否=>取剩余等待时间
  1. maxWait - (time - lastInvokeTime)

这里是不是就是节流中

  1. // 下次触发 func 剩余时间 
  2. const remaining = wait - (now - previous);

4.判断是否立即执行
lodash代码：

  1. maxing && (time - lastInvokeTime) >= maxWait

就往下执行。

这里是不是就是节流中

  1. if (remaining <= 0 || remaining > wait)

就往下执行。

5.有maxing时，应该如何处理函数
lodash代码：如果是节流函数就执行

  1. // 循环定时器中处理调用
  2. timerId = startTimer(timerExpired, wait);
  3. return invokeFunc(lastCallTime);

节流函数中：

  1. timeout = setTimeout(function () {
  2.     timeout = null;
  3.     previous = options.leading === false ? 0 : getNow(); // 这里是将previous重新赋值当前时间
  4.     showResult(context, args);
  5. }, remaining);

总之，lodashmaxWait部分，尽管参数名多，但实际上就是节流函数中，判断剩余时间**remaining**。不需要等待，就直接立即执行，否则就到剩余时间就执行一次，依次类推。

对外 3 个方法

  1. debounced.cancel = cancel // 取消函数延迟执行
  2. debounced.flush = flush // 立即执行 func
  3. debounced.pending = pending // 检查当前是否在计时中

演示地址

可以去Github仓库查看演示代码

跟着大佬学系列

主要是日常对每个进阶知识点的摸透，跟着大佬一起去深入了解JavaScript的语言艺术。

后续会一直更新，希望各位看官不要吝啬手中的赞。

❤️ 感谢各位的支持！！！

❤️ 如果有错误或者不严谨的地方，请务必给予指正，十分感谢！！！

❤️ 喜欢或者有所启发，欢迎 star！！！

参考

原文地址

【跟着大佬学JavaScript】之lodash防抖节流合并