罗罗编程学习记录
本页内容 展开查看

03.10.1 防抖节流与柯里化

所属:全栈开发面试题库 / 03 前端基础与 Web 开发 / 03.10 前端手写实现

覆盖范围

  • 防抖 debounce:trailing 默认、leading 立即执行、cancel/flush、this 与参数透传
  • 节流 throttle:时间戳 + 定时器双实现、leading/trailing 组合
  • 柯里化 currying:多段参数收集、占位符、this 绑定
  • 偏函数与函数组合:partial、compose、pipe

高频题速览

编号 题目 难度 频率
03.10.1-001 手写防抖并支持 leading/trailing 与 cancel 进阶 ★★★★★
03.10.1-002 手写节流并说明时间戳与定时器两种实现差异 进阶 ★★★★★
03.10.1-003 防抖与节流的使用场景与边界 基础 ★★★★★
03.10.1-004 手写柯里化并支持任意参数数量与占位符 进阶 ★★★★
03.10.1-005 偏函数与 bind 的区别 基础 ★★★
03.10.1-006 compose 与 pipe 的实现与执行顺序 进阶 ★★★★
03.10.1-007 防抖函数为什么会丢失 this?如何修复 进阶 ★★★★
03.10.1-008 防抖 immediate 模式下 cancel 行为差异 高级 ★★★

03.10.1-001 手写防抖并支持 leading/trailing 与 cancel

一句话结论

防抖是把连续高频调用合并为一次:在最后一次调用后等待 wait 再执行(trailing),或在第一次立即执行并静默后续调用(leading);通过闭包保存 timer、ctx、args,并暴露 cancel 与 flush。

概念解释

  • trailing:默认模式,停止触发后再执行,适合搜索输入。
  • leading:第一次触发立即执行,适合按钮防连点。
  • cancel:清除定时器并丢弃待执行调用。
  • flush:立即执行一次待调用。

原理流程

  1. 闭包持有 timer、lastCallTime、lastInvokeTime、ctx、args。
  2. 每次调用进入 pending:清掉旧 timer。
  3. 根据 leading 决定是否立即触发;否则等待 wait 后触发 trailing。
  4. cancel 时清 timer 并重置状态。

代码 / 示例

function debounce(fn, wait = 0, { leading = false, trailing = true } = {}) {
  let timer = null;
  let lastArgs = null;
  let lastCtx = null;

  function invoke() {
    if (trailing && lastArgs) {
      fn.apply(lastCtx, lastArgs);
    }
    lastArgs = null;
    lastCtx = null;
  }

  function debounced(...args) {
    lastArgs = args;
    lastCtx = this;
    if (timer) clearTimeout(timer);
    if (leading && !timer) {
      fn.apply(this, args);
      lastArgs = null;
      lastCtx = null;
    }
    timer = setTimeout(() => {
      timer = null;
      invoke();
    }, wait);
  }

  debounced.cancel = () => {
    if (timer) clearTimeout(timer);
    timer = null;
    lastArgs = null;
    lastCtx = null;
  };

  debounced.flush = () => {
    if (timer) clearTimeout(timer);
    timer = null;
    invoke();
  };

  return debounced;
}

常见误区

  • 误区:leading 与 trailing 可同时关闭;正解:两者都 false 时函数永不执行,属于无效配置。
  • 误区:防抖只关心函数体;正解:必须通过 apply(ctx, args) 保留 this 与事件对象,否则在 DOM 监听里会丢失。

追问

  • Q:React 中用 debounce 包装事件回调有什么坑? A:SyntheticEvent 会被回收,需要在防抖外先 e.persist() 或把所需字段拷贝出来。
  • Q:防抖为什么在卸载时要 cancel? A:否则组件卸载后定时器仍触发 setState,产生内存泄漏与警告。

03.10.1-002 手写节流并说明时间戳与定时器两种实现差异

一句话结论

节流保证在 wait 时间间隔内最多执行一次;时间戳实现首尾都立即触发(leading 默认 true),定时器实现尾部触发(trailing 默认 true),Lodash 节流默认两者组合。

概念解释

  • 时间戳法:记录上次执行时间,若 now - last >= wait 则执行。
  • 定时器法:每次调用重置/启动定时器,到点执行一次。
  • 组合:leading 先执行,trailing 末尾补一次。

原理流程

  1. 时间戳法:进入函数立刻判断时间差。
  2. 定时器法:进入函数启动定时器,到点执行并清空。
  3. 组合法:同时维护两个状态,避免 leading 与 trailing 同时触发。

代码 / 示例

function throttle(fn, wait = 0) {
  let lastTime = 0;
  let timer = null;
  return function (...args) {
    const now = Date.now();
    const remaining = wait - (now - lastTime);
    if (remaining <= 0) {
      if (timer) { clearTimeout(timer); timer = null; }
      lastTime = now;
      fn.apply(this, args);
    } else if (!timer) {
      timer = setTimeout(() => {
        lastTime = Date.now();
        timer = null;
        fn.apply(this, args);
      }, remaining);
    }
  };
}

常见误区

  • 误区:节流等于防抖;正解:防抖是合并为一次,节流是固定频率执行,scroll 拖拽场景用节流,搜索输入用防抖。
  • 误区:时间戳法尾部一定执行;正解:纯时间戳法最后一次若未达到间隔不会触发,需 trailing 补齐。

追问

  • Q:滚动 resize 用哪种? A:resize 用节流 trailing,避免最后一帧丢失;拖拽 mousemove 用节流 leading 让反馈及时。
  • Q:节流函数中 this 如何保留? A:与防抖一致,用普通函数 + apply(this, args),不要写成箭头函数。

03.10.1-003 防抖与节流的使用场景与边界

一句话结论

防抖用于合并连续输入(搜索框、resize 收尾、表单校验),节流用于限制高频事件频率(scroll、mousemove、拖拽、按钮限流);边界是在组件卸载时清理、在异步回调中保留事件对象、在 React 依赖数组中保持稳定引用。

概念解释

  • 输入合并:search input 等停止输入后再请求。
  • 频率控制:滚动监听、鼠标移动、上报采样。
  • 引用稳定:useEffect 中创建的 debounce 函数必须用 useCallback 或 useRef 持有,避免每次渲染重建。

原理流程

  1. 识别事件是"最后一次才有意义"还是"过程中也要有反馈"。
  2. 前者用防抖,后者用节流。
  3. 在组件卸载钩子调用 cancel。

代码 / 示例

useEffect(() => {
  const onResize = debounce(() => console.log("resize"), 200);
  window.addEventListener("resize", onResize);
  return () => onResize.cancel();
}, []);

常见误区

  • 误区:所有高频事件都要防抖;正解:scroll 跟随位置用节流,否则拖拽不跟手。
  • 误区:在 render 中直接 onChange={debounce(f, 300)};正解:每次 render 都新建防抖函数,闭包状态丢失,必须 useRef/useMemo。

追问

  • Q:按钮防重复点击用防抖还是节流? A:用 leading 防抖,立即触发一次后静默后续,300ms 内只触发一次。
  • Q:搜索防抖的 wait 设多少? A:常见 300ms,超过 500ms 用户感知明显;可叠加输入校验,未通过不触发。

03.10.1-004 手写柯里化并支持任意参数数量与占位符

一句话结论

柯里化把多参数函数转换为一系列单参数函数,直到参数凑齐才执行;通过闭包累计参数,参数数量达到函数元数时调用原函数。

概念解释

  • 元数(arity):函数期望的参数数量。
  • 柯里化:每次返回新函数,收集一个或多个参数。
  • 占位符:允许跳过某些位置,稍后再补。

原理流程

  1. 记录原函数长度与已收集参数。
  2. 每次调用合并参数。
  3. 检查非占位符参数是否达到 arity;达到则调用原函数,否则继续返回柯里化函数。

代码 / 示例

function curry(fn, ...args) {
  const arity = fn.length;
  return function (...rest) {
    const all = [...args, ...rest];
    const filled = all.filter((x) => x !== curry.placeholder).length;
    if (filled >= arity) {
      return fn.apply(this, all);
    }
    return curry(fn, ...all);
  };
}
curry.placeholder = Symbol("curry");

常见误区

  • 误区:柯里化只能一次传一个参数;正解:可以一次传多个,只要未达元数就继续返回函数。
  • 误区:arguments.length 等于 fn.length;正解:剩余参数与默认参数会让 fn.length 不等于实际期望参数,复杂场景需显式传 arity。

追问

  • Q:柯里化与偏函数区别? A:偏函数是固定部分参数返回接受剩余参数的函数,参数数量不一定逐次递减。
  • Q:为什么在函数式编程中有用? A:便于组合与延迟执行,配合 compose 形成管道。

03.10.1-005 偏函数与 bind 的区别

一句话结论

偏函数是固定部分参数返回新函数,参数顺序与原函数一致;Function.prototype.bind 除了固定参数还会永久绑定 this 到第一个参数,且返回的函数不能被 new 覆盖 this。

概念解释

  • partial:只固定参数,不绑定 this。
  • bind:绑定 this + 部分参数,且可作为构造函数使用时行为受限。

原理流程

  1. 偏函数:闭包收集前置参数,调用时拼接。
  2. bind:返回新函数,内部 fn.apply(ctx, args.concat(rest));若被 new 调用,this 指向新实例而非绑定的 ctx。

代码 / 示例

function partial(fn, ...preset) {
  return (...rest) => fn(...preset, ...rest);
}
const add = (a, b, c) => a + b + c;
const add5 = partial(add, 10, 20);
add5(3); // 33

常见误区

  • 误区:bind 等于 partial;正解:bind 绑定 this,partial 不绑定,且 bind 返回的函数作为构造函数时 this 仍指向新实例。
  • 误区:bind 可以多次 bind 修改 this;正解:第一次 bind 之后 this 被锁死,后续 bind 无效。

追问

  • Q:bind 之后 new 会发生什么? A:忽略绑定的 this,按构造函数正常初始化对象。
  • Q:为什么事件代理常用 bind? A:把 handler 与目标元素 id 绑定,避免在每次渲染时创建新闭包。

03.10.1-006 compose 与 pipe 的实现与执行顺序

一句话结论

compose 从右向左组合函数(数学习惯),pipe 从左向右(数据流习惯);两者都是把多个一元函数串成一个函数。

概念解释

  • compose:compose(f, g, h)(x) = f(g(h(x)))。
  • pipe:pipe(f, g, h)(x) = h(g(f(x)))。

原理流程

  1. reduce 或 reduceRight 把函数依次应用到参数上。
  2. 中间函数必须是一元的,否则需要先部分应用。

代码 / 示例

const compose = (...fns) => (x) => fns.reduceRight((v, f) => f(v), x);
const pipe = (...fns) => (x) => fns.reduce((v, f) => f(v), x);

常见误区

  • 误区:compose 与 pipe 性能差异大;正解:只是方向不同,性能一致。
  • 误区:可以组合任意函数;正解:中间函数返回值必须与下一函数输入匹配,否则要做类型对齐。

追问

  • Q:Redux 的 applyMiddleware 用什么? A:compose,让中间件从右向左包裹 dispatch。
  • Q:如何支持异步函数组合? A:reduce 中用 await 串联,返回 Promise。

03.10.1-007 防抖函数为什么会丢失 this?如何修复

一句话结论

若防抖包装函数写成箭头函数或使用了 const that = this 但内部定时器回调里用错作用域,就会丢失原调用者的 this;修复方式是在外层函数用普通函数,保存 this 与 args,在 setTimeout 回调里 apply(ctx, args)。

概念解释

  • 外层 this:由防抖函数的调用方式决定(el.onclick = debounce(f) 时 this 指向 el)。
  • 内层回调:setTimeout 回调在非严格模式下 this 是 window,严格模式是 undefined。

原理流程

  1. 防抖外层是普通函数,捕获 this。
  2. 定时器回调闭包引用保存的 ctx。
  3. 真正执行 fn.apply(ctx, args)。

代码 / 示例

function debounce(fn, wait) {
  let timer;
  return function (...args) {
    const ctx = this;
    clearTimeout(timer);
    timer = setTimeout(() => fn.apply(ctx, args), wait);
  };
}

常见误区

  • 误区:外层写成箭头函数也没事;正解:箭头函数的 this 是定义时的 this,不是调用时的,DOM 监听场景会丢失。
  • 误区:参数不重要;正解:事件对象必须通过 args 透传,否则 e.target 在异步回调中访问不到。

追问

  • Q:React 合成事件有什么不同? A:SyntheticEvent 池化,异步访问前必须 persist() 或拷贝字段。
  • Q:class 组件方法防抖怎么写? A:在 constructor 中 this.handle = debounce(this.handle.bind(this), 300),否则每次 render 重新绑定。

03.10.1-008 防抖 immediate 模式下 cancel 行为差异

一句话结论

leading 模式下第一次立即执行后,cancel 只能清除尚未触发的 trailing 调用,已经执行过的 leading 不会回滚;如果业务需要"反悔",必须在 leading 之外另做撤销机制。

概念解释

  • leading 已执行:副作用已经发生(如发请求)。
  • trailing 待执行:只是定时器未触发,cancel 可丢弃。

原理流程

  1. leading 触发:直接调用 fn,副作用已发生。
  2. 后续调用:进入 trailing 等待。
  3. cancel:只清 timer,无法撤销已发生副作用。

代码 / 示例

debounced.click(); // 立即发请求
debounced.cancel(); // 只是取消后续 trailing,无法撤回请求

常见误区

  • 误区:cancel 能撤销 leading 调用;正解:JS 没有回滚已发生副作用的机制,需要业务层设计 abort/undo。
  • 误区:cancel 后立即再触发会重新走 leading;正解:取决于实现,若清除了 timer 与 lastArgs,下一次调用会重新进入 leading。

追问

  • Q:搜索请求如何取消? A:用 AbortController,在 cancel 或新请求发起时 abort 上一个。
  • Q:按钮防连点如何避免"第一次也算数"? A:使用 trailing 防抖或显式 disabled 状态,leading 只适合"开始"语义明确的操作。

待整理清单

  • [ ] 防抖在 React 18 并发模式下的行为
  • [ ] 节流在 IntersectionObserver 替代 scroll 监听中的组合
  • [ ] Lodash debounce 的 maxWait 实现