利用JavaScript闭包实现防抖与节流函数

作者:小括号时间:2026-11-17 15:24:41浏览:86

结合JavaScript闭包持久化与隔离状态的机制,逐步实现基础版与完整版防抖(debounce)及节流(throttle)函数,说明this绑定、定时器清理与场景选型依据。

在前端处理输入框联想、滚动加载、窗口缩放或按钮连点等高频事件时,直接执行回调函数会导致大量重复计算或多余请求。防抖(Debounce)与节流(Throttle)通过控制函数的触发节奏来解决这一问题,而它们的核心实现都依赖 JavaScript 闭包——利用外层函数返回的包装函数持久持有定时器标识或时间戳,在不污染全局作用域的前提下,跨多次事件调用共享并隔离状态。下面从闭包的运行机制出发,依次实现可用的防抖与节流函数,并说明各自的参数边界与选用方法。

为什么防抖和节流都离不开闭包

读者在刚开始写防抖或节流时,常会遇到一个直觉问题:如果把记录定时器的变量 timer 直接写在事件处理函数内部,每次触发事件时函数都会重新执行并创建一个新的局部变量,上一次设置的定时器无法被读取和清除;如果把 timer 放到全局作用域,页面中只要同时存在两个需要防抖的输入框,它们就会互相覆盖同一个变量。

闭包正好同时解决了“持久化保存”和“实例隔离”两个问题。当外层高阶函数(例如 debounce(fn, wait))被调用时,它会在自身函数作用域内声明状态变量(如 timer 或 lastTime),并返回一个内层包装函数。由于内层函数引用了外层作用域中的状态变量,JavaScript 引擎不会在外层函数返回后回收这些变量,而是将其保留在闭包对应的词法环境中。

每次调用外层工厂函数,都会创建一份彼此独立的状态空间。给搜索框和窗口缩放事件分别生成防抖函数时,两个包装函数各自读写属于自己的 timer,既能在连续触发期间记住上一次的状态,又不会互相干扰。

利用JavaScript闭包实现防抖与节流函数
图 1:闭包为每次工厂调用建立独立词法环境,使状态得以跨次保留且实例间互不干扰

实现防抖函数:在停止触发后执行

防抖的核心规则是:事件触发后并不立刻执行目标函数,而是等待设定的延迟时间 wait 毫秒;如果在等待期间事件再次被触发,就取消上一次未执行的定时器并重新开始计时,直到连续静默满 wait 毫秒后才执行一次。

基础版防抖函数怎么写

要将上述规则写成代码,只需要在外层函数声明 let timer = null,并在内层返回的包装函数中按“先清除旧定时器,再开启新定时器”的顺序操作即可。以下示例可直接在浏览器开发者工具控制台或 Node.js(v18 及以上版本)中运行:

function debounce(fn, wait = 300) {
  let timer = null;

  return function (...args) {
    // 每次触发时,如果存在尚未执行的定时器,先将其清除
    if (timer !== null) {
      clearTimeout(timer);
    }

    // 使用箭头函数继承外层包装函数的 this,并透传所有参数
    timer = setTimeout(() => {
      timer = null;
      fn.apply(this, args);
    }, wait);
  };
}

// 运行示例:模拟连续输入关键词,仅在停顿 300ms 后发起一次查询
const handleSearch = debounce(function (keyword) {
  console.log('发起搜索请求,关键词:', keyword);
}, 300);

handleSearch('J');
handleSearch('Ja');
handleSearch('JavaScript');
示例输出(约 300ms 后仅输出一次)发起搜索请求,关键词: JavaScript
容易出错的地方:在 DOM 事件监听(如 input.addEventListener('input', handleSearch))中,浏览器会把触发事件的 DOM 元素绑定为包装函数的 this,同时把事件对象 event 作为参数传入。如果 setTimeout 内部使用普通函数 function () {} 且没有提前保存 const context = this,执行 fn 时 this 会丢失为全局对象或 undefined。上面示例使用箭头函数配合 fn.apply(this, args),同时保留了正确的 this 指向与全部实参。
利用JavaScript闭包实现防抖与节流函数
图 2:防抖函数的四步执行流与连续触发时的定时器重置回环

如果需要“首次点击立刻执行”,并且支持手动取消怎么办

基础版防抖总是在停止触发后才执行,适合搜索框输入。但如果是提交表单按钮防连点,用户点击后通常希望立刻响应一次,并在接下来的 wait 毫秒内忽略重复点击;此外,在组件销毁或页面跳转前,也往往需要主动取消尚未到期的定时器。

这只需在闭包中增加一个控制标志 immediate,同时在返回的包装函数上挂载 cancel 方法,让外部可以随时清理闭包内的 timer:

function debounce(fn, wait = 300, immediate = false) {
  let timer = null;

  const debounced = function (...args) {
    if (timer !== null) {
      clearTimeout(timer);
    }

    if (immediate) {
      // timer 为 null 说明当前不处于冷却期,可以立即执行
      const callNow = timer === null;
      timer = setTimeout(() => {
        timer = null;
      }, wait);

      if (callNow) {
        fn.apply(this, args);
      }
    } else {
      timer = setTimeout(() => {
        timer = null;
        fn.apply(this, args);
      }, wait);
    }
  };

  // 挂载 cancel 方法,直接操作闭包中的 timer
  debounced.cancel = function () {
    if (timer !== null) {
      clearTimeout(timer);
      timer = null;
    }
  };

  return debounced;
}

// 运行示例:启用 immediate,连续点击提交按钮时仅首次立即触发
const submitOrder = debounce(function (orderId) {
  console.log('提交订单:', orderId);
}, 1000, true);

submitOrder('ORD-101'); // 立即执行
submitOrder('ORD-101'); // 冷却期内忽略
// 若页面销毁前需终止潜在定时器:submitOrder.cancel();
示例输出(立即输出一次,1000ms 内重复调用被忽略)提交订单: ORD-101

实现节流函数:按固定间隔稳定触发

如果用户的操作一直持续不断(例如长列表高速滚动或连续拖拽滑块),防抖会因为不停被重置而迟迟不执行目标函数。遇到需要“按固定时间间隔给出过程反馈”的场景,就需要改用节流:无论事件触发多密集,在每段 wait 毫秒的周期内,目标函数最多只执行一次。

利用闭包保存的状态变量不同,节流有三种常见实现方式,它们在“首次触发是否立刻执行”和“停止触发后最后一次是否补执行”上存在明显差异。

方式一:时间戳版(首次立即执行,停止后不补执行)

在闭包中保存上一次执行的时间戳 lastTime = 0。每次触发包装函数时,用当前时间减去 lastTime,只有差值大于或等于 wait 才执行目标函数并更新 lastTime。由于初始 lastTime 为 0,第一次触发时差值必然大于 wait,因此会立即执行;但如果最后一次触发落在冷却间隔内,它不会再额外补执行。

function throttleByTimestamp(fn, wait = 300) {
  let lastTime = 0;

  return function (...args) {
    const now = Date.now();
    if (now - lastTime >= wait) {
      lastTime = now;
      fn.apply(this, args);
    }
  };
}

方式二:定时器版(首次等待后执行,停止后会补执行)

在闭包中保存定时器标识 let timer = null。只要 timer 不为空,说明当前周期还在等待执行,直接跳过本次调用;当 timer 为空时开启一个 wait 毫秒的定时器,到期后执行目标函数并把 timer 重置为 null。这种方式在第一次触发时不会立即执行,但即使事件停止,处于等待中的那一次调用也会在到期后完成。

function throttleByTimer(fn, wait = 300) {
  let timer = null;

  return function (...args) {
    if (timer !== null) {
      return;
    }

    timer = setTimeout(() => {
      timer = null;
      fn.apply(this, args);
    }, wait);
  };
}

方式三:时间戳与定时器结合版(首尾兼顾)

很多交互场景既希望首次触发能立刻响应(不卡顿),又希望操作结束后的最终位置或状态能被同步到界面(不丢尾)。这时可以在闭包中同时维护 lastTime 和 timer,通过计算距离下一次可执行的剩余时间 remaining = wait - (now - lastTime) 来决定是立即执行,还是挂起一个剩余时间的定时器,并附上 cancel() 清理能力。

function throttle(fn, wait = 300) {
  let lastTime = 0;
  let timer = null;

  const throttled = function (...args) {
    const now = Date.now();
    // 剩余等待时间;若为首次调用或距上次已满 wait,则 remaining <= 0
    const remaining = wait - (now - lastTime);

    if (remaining <= 0 || remaining > wait) {
      if (timer !== null) {
        clearTimeout(timer);
        timer = null;
      }
      lastTime = now;
      fn.apply(this, args);
    } else if (timer === null) {
      // 尚未到间隔但也没有排队定时器时,安排一次尾调用补齐最终状态
      timer = setTimeout(() => {
        lastTime = Date.now();
        timer = null;
        fn.apply(this, args);
      }, remaining);
    }
  };

  throttled.cancel = function () {
    if (timer !== null) {
      clearTimeout(timer);
      timer = null;
    }
    lastTime = 0;
  };

  return throttled;
}

// 运行示例:模拟在 0ms、150ms、450ms、600ms 触发,间隔设为 500ms
const onScroll = throttle(function (scrollTop) {
  console.log('同步滚动位置:', scrollTop);
}, 500);

onScroll(10);                        // 0ms:立即执行
setTimeout(() => onScroll(120), 150); // 150ms:设剩余 350ms 定时器
setTimeout(() => onScroll(380), 450); // 450ms:已有定时器,跳过
setTimeout(() => onScroll(520), 600); // 500ms 先执行 120,600ms 距 500ms 不足 500ms,设尾调用并于 1000ms 执行 520
示例输出(首尾均得到响应,中间冗余调用被合并)同步滚动位置: 10 同步滚动位置: 120 同步滚动位置: 520
条件说明:结合版代码中的 remaining > wait 判断专门用于处理系统时钟被往回调的场景(此时 now - lastTime 为负数,remaining 会大于 wait)。在现代浏览器和 Node.js 中如果需要完全不受系统时钟调整影响的单调递增时间,也可以用 performance.now() 替代 Date.now()。另外,使用定时器版或结合版时,组件卸载前同样应调用 throttled.cancel() 清除残留定时器。
利用JavaScript闭包实现防抖与节流函数
图 3:时间戳版、定时器版与首尾兼顾版节流函数在连续高频输入下的执行点差异

防抖与节流如何选择?常见场景与排查要点

在实际开发中,选择防抖还是节流不看函数名,而看业务关注的是“最后停下来那一次的结果”,还是“过程持续期间的稳定反馈”。

判断维度 防抖(Debounce) 节流(Throttle)
执行时机 连续触发期间不执行,停顿满 wait 毫秒后执行(可选首次立即执行) 无论触发多密集,每 wait 毫秒周期内最多执行一次
闭包状态 主要维护 timer 定时器标识 维护 lastTime 时间戳和/或 timer
典型场景 搜索框输入联想、表单字段校验、窗口 resize 后重算布局、提交按钮防连点 页面 scroll 滚动加载位置检测、拖拽元素坐标同步、鼠标移动跟随计算

即使实现代码本身没有错误,落地到具体项目或框架中时,以下三类问题仍最容易导致防抖或节流看起来“完全没有生效”:

  • 在每次渲染或事件中重复生成新闭包:如果在组件每次重新渲染时都直接写 onInput={() => debounce(handleInput, 300)()},每次触发都会创建一个全新的闭包和全新的 timer,导致完全没有防抖效果。正确做法是在初始化阶段只调用一次 debounce 或 throttle 生成包装函数并保存引用(例如在 React 中配合 useMemo / useRef,或在模块/组件实例创建时赋值)。
  • 忽略异步执行时的 this 与事件参数:直接把 fn() 放进 setTimeout,会导致依赖 this 或 event.target.value 的回调函数拿到错误值。始终通过剩余参数 (...args) 与 fn.apply(this, args) 透传上下文。
  • 未在生命周期结束时取消定时器:当用户快速触发防抖后立即跳转路由或销毁组件,闭包里的定时器仍会在 wait 毫秒后触发,可能引发修改已销毁节点或空引用异常。在销毁钩子中主动调用 cancel() 即可切断后续回调。
利用JavaScript闭包实现防抖与节流函数
图 4:防抖与节流的业务选型路径及开发落地检查清单
作者最新文章
相关文章
更多