手写防抖与节流核心代码 深入解析高频事件优化原理与面试必考题

引言:理解高频事件优化的必要性
在现代Web开发中,高频事件(如窗口resize、滚动scroll、输入搜索、鼠标移动等)是性能优化的核心挑战。当用户频繁触发这些事件时,如果不进行优化,会导致浏览器频繁执行回调函数,造成页面卡顿、CPU占用过高甚至浏览器崩溃。防抖(Debounce)和节流(Throttle)正是解决这一问题的两种核心技术。它们通过控制函数执行的频率,将高频触发转化为低频执行,从而显著提升用户体验和页面性能。在面试中,手写防抖和节流代码是考察JavaScript基础、闭包理解和实际应用能力的经典题目。本文将从原理、代码实现、区别与联系、实际应用等多个维度进行深入解析,帮助读者彻底掌握这两种技术。
一、防抖(Debounce)的核心原理与实现
1.1 防抖的基本概念
防抖的核心思想是:
在事件触发后延迟一段时间执行函数,如果在这段时间内事件再次被触发,则重新计时延迟
。这就像在电梯里:如果有人进来,电梯门会重新关闭并等待;只有当一段时间内没有人进来时,电梯才会启动运行。防抖适用于那些需要等待用户操作完全结束后再执行的场景,例如搜索框输入、窗口调整结束后的布局计算等。
1.2 手写防抖核心代码
下面是一个基础的防抖函数实现,支持立即执行(leading)和取消功能:
/**
* 防抖函数
* @param {Function} func 需要防抖的函数
* @param {number} wait 等待时间(毫秒)
* @param {boolean} immediate 是否立即执行(第一次触发立即执行,后续等待)
* @returns {Function} 防抖后的函数
*/
function debounce(func, wait, immediate = false) {
let timeout = null; // 存储定时器
let result; // 存储函数返回值

// 防抖核心函数
const debounced = function(…args) {
const context = this; // 保存this上下文

// 如果存在定时器,说明上次触发还未结束,清除定时器重新计时
if (timeout) {
clearTimeout(timeout);
}

// 是否立即执行模式
if (immediate) {
// 如果没有定时器,说明是第一次触发,立即执行
const callNow = !timeout;
// 设置定时器,在wait时间后清空timeout,允许下次立即执行
timeout = setTimeout(() => {
timeout = null;
}, wait);

// 第一次触发立即执行
if (callNow) {
result = func.apply(context, args);
return result;
}
} else {
// 普通模式:设置定时器,在wait时间后执行函数
timeout = setTimeout(() => {
func.apply(context, args);
// 执行后清空timeout,允许后续触发
timeout = null;
}, wait);
}

return result;
};

// 取消防抖:清除定时器,恢复初始状态
debounced.cancel = function() {
if (timeout) {
clearTimeout(timeout);
timeout = null;
}
};

// 立即执行:如果当前有定时器,强制立即执行一次并清空定时器
debounced.flush = function() {
if (timeout) {
clearTimeout(timeout);
func.apply(this, arguments);
timeout = null;
}
};

return debounced;
}
1.3 代码逐行解析
闭包存储
:通过闭包保存
timeout
变量,确保每次调用时能访问到上一次的定时器状态。
定时器管理
:
setTimeout
用于延迟执行,
clearTimeout
用于取消上一次的延迟。每次触发事件时,先清除旧定时器,再设置新定时器,从而实现”重新计时”。
上下文绑定
:使用
apply
确保函数执行时的
this
指向正确,同时传递事件参数
args
。
立即执行模式
:通过
callNow
判断是否是第一次触发,如果是则立即执行,后续触发进入等待模式。这种模式适用于”第一次输入立即搜索,后续等待”的场景。
取消与强制执行
:
cancel
方法用于取消等待(例如页面卸载时),
flush
方法用于强制立即执行当前函数(例如用户提交表单时)。
1.4 防抖的应用场景与示例
场景:搜索框实时搜索
假设有一个输入框,用户输入关键词后实时显示搜索结果。如果每次输入都立即发送请求,会导致请求过多、服务器压力大。使用防抖后,只有用户停止输入一段时间后才会发送请求。
// 模拟搜索函数
function search(query) {
console.log(`发送搜索请求: ${query}`);
// 实际项目中这里会发送AJAX请求
}

// 创建防抖后的搜索函数,等待300ms
const debouncedSearch = debounce(search, 300);

// 绑定输入事件
document.getElementById(‘searchInput’).addEventListener(‘input’, (e) => {
debouncedSearch(e.target.value);
});

// 用户输入过程:
// 输入”a” -> 无输出(等待中)
// 100ms后输入”ab” -> 无输出(重新等待)
// 200ms后输入”abc” -> 无输出(重新等待)
// 停止输入300ms后 -> 输出”发送搜索请求: abc”
场景:窗口resize事件
窗口大小改变时,需要重新计算布局。如果每次resize都执行计算,会导致页面卡顿。
function resizeHandler() {
console.log(‘重新计算布局’);
// 复杂的DOM计算…
}

const debouncedResize = debounce(resizeHandler, 500);
window.addEventListener(‘resize’, debouncedResize);
二、节流(Throttle)的核心原理与实现
2.1 节流的基本概念
节流的核心思想是:
在一段时间内,无论事件触发多少次,函数只执行一次
。这就像水龙头:无论你如何快速开关,水流速度是固定的。节流适用于那些需要持续响应但不能太频繁的场景,例如滚动加载、鼠标移动跟随、拖拽等。
2.2 手写节流核心代码
节流有两种常见实现方式:
时间戳版
(立即执行)和
定时器版
(延迟执行)。下面提供一个综合版本,支持两种模式:
/**
* 节流函数
* @param {Function} func 需要节流的函数
* @param {number} wait 等待时间(毫秒)
* @param {Object} options 配置项 { leading: 是否首次执行, trailing: 是否结束后执行 }
* @returns {Function} 节流后的函数
*/
function throttle(func, wait, options = {}) {
let timeout = null;
let previous = 0; // 上次执行时间戳
let context, args;

// 处理配置项
const { leading = true, trailing = true } = options;

// 如果leading和trailing都为false,至少需要一个为true
if (!leading && !trailing) {
throw new Error(‘leading和trailing不能同时为false’);
}

// 节流核心函数
const throttled = function(…_args) {
context = this;
args = _args;

const now = Date.now(); // 当前时间戳

// 如果是首次执行且leading为true
if (!previous && leading) {
previous = now;
func.apply(context, args);
return;
}

// 计算距离上次执行的时间
const remaining = wait – (now – previous);

// 如果剩余时间小于等于0,说明可以执行
if (remaining <= 0) { previous = now; func.apply(context, args); // 清空定时器(trailing模式) if (timeout) { clearTimeout(timeout); timeout = null; } } // 如果剩余时间大于0且trailing为true,设置定时器 else if (!timeout && trailing) { timeout = setTimeout(() => {
previous = Date.now(); // 更新时间戳
timeout = null;
func.apply(context, args);

// 如果leading为true,执行后重置previous,避免下次立即执行
if (!leading) {
previous = 0;
}
}, remaining);
}
};

// 取消节流
throttled.cancel = function() {
if (timeout) {
clearTimeout(timeout);
}
previous = 0;
timeout = null;
};

// 立即执行:如果有定时器,强制执行并清空
throttled.flush = function() {
if (timeout) {
clearTimeout(timeout);
func.apply(context, args);
previous = Date.now();
timeout = null;
}
};

return throttled;
}
2.3 代码逐行解析
时间戳管理
:通过
previous
记录上次执行的时间戳,计算当前时间与上次执行的时间差,决定是否执行。
两种模式
:
时间戳版
:通过
now – previous >= wait
判断,立即执行,适合滚动开始时立即响应。
定时器版
:通过
setTimeout
延迟执行,适合滚动结束后继续响应。
配置项
:
leading
控制是否首次立即执行,
trailing
控制是否在结束后补充执行。例如:
{ leading: true, trailing: false }
:首次立即执行,后续每wait时间执行一次。
{ leading: false, trailing: true }
:首次不执行,等待结束后执行一次。
{ leading: true, trailing: true }
:首次立即执行,结束后补充执行一次(需注意重复执行问题)。
上下文与参数
:与防抖类似,使用
apply
绑定
this
和参数。
2.4 节流的应用场景与示例
场景:滚动加载更多
当用户滚动页面到底部时,加载更多内容。如果每次滚动都触发,会导致频繁请求和渲染。
// 模拟加载函数
function loadMore() {
console.log(‘加载更多数据…’);
// 实际项目中这里会发送AJAX请求并更新DOM
}

// 创建节流函数,每500ms最多执行一次
const throttledLoad = throttle(loadMore, 500, { leading: false, trailing: true });

// 绑定滚动事件
window.addEventListener(‘scroll’, throttledLoad);

// 用户滚动过程:
// 快速滚动多次 -> 只在滚动停止后(或每500ms)执行一次
// 避免了频繁触发导致的性能问题
场景:鼠标移动跟随
一个跟随鼠标移动的浮动元素,如果每移动1px就更新位置,会导致大量重绘。
// 模拟跟随函数
function followMouse(e) {
const element = document.getElementById(‘follower’);
element.style.left = e.pageX + ‘px’;
element.style.top = e.pageY + ‘px’;
console.log(`更新位置: (${e.pageX}, ${e.pageY})`);
}

// 创建节流函数,每100ms更新一次
const throttledFollow = throttle(followMouse, 100, { leading: true, trailing: false });

document.addEventListener(‘mousemove’, throttledFollow);
三、防抖与节流的区别与联系
3.1 核心区别对比表
特性
防抖(Debounce)
节流(Throttle)
执行时机
事件停止触发后延迟执行
事件触发期间按固定频率执行
执行次数
多次触发只执行最后一次
多次触发按时间间隔执行
适用场景
搜索输入、窗口调整结束
滚动加载、鼠标移动、拖拽
核心逻辑
每次触发重新计时
每次触发检查时间间隔
用户体验
等待用户操作完成
持续反馈但不频繁
3.2 联系与共同点
都是闭包应用
:都依赖闭包保存状态(定时器、时间戳)。
都支持取消和强制执行
:提供
cancel
和
flush
方法增强控制。
都用于性能优化
:减少函数执行频率,避免浏览器重排重绘。
都可自定义配置
:支持立即执行、延迟执行等模式。
3.3 如何选择?
防抖
:当事件结束后才需要执行一次时使用。例如:输入框搜索(用户停止输入后搜索)、窗口resize结束后的计算。
节流
:当事件过程中需要持续响应但不能太频繁时使用。例如:滚动加载(滚动过程中持续加载)、鼠标跟随(移动过程中持续更新)。
四、高频事件优化原理深入解析
4.1 浏览器事件循环与性能瓶颈
浏览器的事件循环(Event Loop)将任务分为宏任务(如setTimeout、事件回调)和微任务(如Promise)。高频事件触发时,会生成大量宏任务,导致主线程阻塞。具体瓶颈包括:
DOM操作
:每次回调可能触发重排(reflow)和重绘(repaint),消耗大量CPU。
网络请求
:频繁发送AJAX请求会占用带宽,增加服务器压力。
内存泄漏
:未清理的定时器或事件监听器会导致内存占用过高。
防抖和节流通过
减少回调执行次数
,直接降低主线程负载,避免上述问题。
4.2 闭包在防抖节流中的作用
闭包是防抖节流实现的核心。它允许函数访问外部变量(如
timeout
、
previous
),即使外部函数已经执行完毕。这确保了状态的持久化:
function outer() {
let state = 0;
function inner() {
state++;
console.log(state);
}
return inner;
}
const fn = outer();
fn(); // 1
fn(); // 2
// 每次调用fn都能访问到同一个state
在防抖节流中,闭包保存了定时器ID和时间戳,使得每次调用时都能判断是否需要执行或重新计时。
4.3 时间戳与定时器的精度问题
时间戳
:基于
Date.now()
,精度高,但可能因浏览器后台运行而延迟。
定时器
:
setTimeout
的最小延迟为4ms(HTML5标准),且受浏览器节流影响。在后台标签页中,定时器可能被大幅延长。
解决方案
:对于精确时间控制,可结合
requestAnimationFrame
(适用于动画),但防抖节流通常使用时间戳和定时器已足够。
五、面试必考题:手写防抖与节流的高级技巧
5.1 面试常见追问
问题1:如何实现一个带立即执行的防抖?
答:参考上文防抖代码的
immediate
参数。核心是判断
!timeout
,如果是第一次触发则立即执行,后续触发重新计时。
问题2:节流的时间戳版和定时器版有什么区别?
答:时间戳版在事件触发时立即执行,适合”开始”场景;定时器版在事件触发后延迟执行,适合”结束”场景。例如,滚动事件:时间戳版在滚动开始立即加载,定时器版在滚动结束后加载。
问题3:防抖和节流能否结合使用?
答:可以。例如,先用节流控制频率,再用防抖确保最后一次执行。但通常场景下选择一种即可。
问题4:如何在React/Vue中使用防抖节流?
答:在React中,可使用
useCallback
+
useRef
保存防抖函数,避免重复创建:
const debouncedSearch = useCallback(
debounce((value) => search(value), 300),
[]
);
在Vue中,可使用
lodash
库或自定义指令。
5.2 手写代码面试技巧
先写基础版本
:先实现简单防抖,再逐步添加功能(立即执行、取消等)。
解释闭包
:主动说明闭包的作用,展示对JavaScript核心概念的理解。
考虑边界情况
:如
this
指向、参数传递、取消功能等。
性能优化
:提及时间戳和定时器的区别,展示深度。
5.3 完整面试代码示例
// 面试手写标准答案(防抖)
function debounce(func, wait) {
let timeout;
return function(…args) {
const context = this;
clearTimeout(timeout);
timeout = setTimeout(() => {
func.apply(context, args);
}, wait);
};
}

// 面试手写标准答案(节流 – 时间戳版)
function throttle(func, wait) {
let previous = 0;
return function(…args) {
const context = this;
const now = Date.now();
if (now – previous >= wait) {
func.apply(context, args);
previous = now;
}
};
}
六、实际项目中的应用与最佳实践
6.1 结合第三方库
虽然手写是面试要求,但实际项目推荐使用成熟的库:
Lodash
:
_.debounce
和
_.throttle
提供了完善的配置和取消功能。
RxJS
:通过
debounceTime
和
throttleTime
操作符实现更复杂的流控制。
6.2 性能监控与调试
使用Chrome DevTools的Performance面板记录事件触发情况,观察回调执行频率。通过
console.time
测量函数执行时间,确保防抖节流有效降低负载。
6.3 常见陷阱与解决方案
this指向丢失
:使用箭头函数或
bind
,但防抖节流内部已用
apply
解决。
参数丢失
:使用
…args
收集参数。
内存泄漏
:在组件卸载时调用
cancel
方法清除定时器。
首次触发延迟
:使用
leading: true
配置解决。
七、总结
防抖和节流是Web性能优化的基石,通过控制函数执行频率,有效解决了高频事件带来的性能问题。手写这两种函数不仅考察JavaScript基础,还考察闭包、定时器、上下文等核心知识。在实际开发中,理解原理后可以灵活选择或自定义实现。面试时,务必清晰解释区别、应用场景,并手写可运行的代码。掌握这两种技术,将使你的代码更高效、用户体验更流畅。