做过一个后台列表,初始化时给每一行的「编辑」按钮绑了点击事件。第一页正常,翻到第二页按钮全失效,新增的行也一样。原因很简单:绑定时页面上只有第一页那几条按钮,后面渲染出来的 DOM 根本没绑过。

当时的修法是每次渲染完重新绑一遍。能跑,但很快又出问题——翻页几次之后,点一下按钮会发好几个请求。因为旧的按钮没被销毁,旧的监听也没解绑,同一批数据被绑了多次。

这两个问题(新元素没绑定、重复绑定)在真实项目里非常常见,而它们的标准解法都是同一个:事件委托。

这篇讲什么:事件怎么绑定、事件对象里有什么、冒泡和捕获是什么顺序、委托为什么能同时解决上面两个问题、高频事件该怎么做。读完你能做到:写列表交互时不再逐个绑定;分得清 stopPropagation 和 preventDefault;知道什么时候该解绑、怎么解绑。

绑定事件:addEventListener 和 onclick

两种方式都能用,差别在于「能绑几个」:

// 方式一:属性赋值,后一个会覆盖前一个
button.onclick = () => console.log("第一次");
button.onclick = () => console.log("第二次");
// 点击只打印「第二次」

// 方式二:注册监听,可以绑多个,按注册顺序执行
button.addEventListener("click", () => console.log("第一次"));
button.addEventListener("click", () => console.log("第二次"));
// 点击依次打印:第一次、第二次

实际项目里统一用 addEventListener,因为要解绑、要控制阶段、要绑多个。第三个参数有三种用法:

写法作用什么时候用
addEventListener("click", fn)默认在冒泡阶段触发绝大多数场景
addEventListener("click", fn, true)在捕获阶段触发,先于冒泡需要在子元素之前拦截,比如点击外部关闭弹窗
{ once: true }触发一次后自动解绑「只执行一次」的初始化、引导
{ passive: true }承诺不调用 preventDefault,滚动更顺touchmove、wheel 这类高频事件

还有一个行为很多人不知道:同一个元素、同一种事件、同一个函数、同一个阶段,注册两次只会生效一次。浏览器会做去重:

function onClick() {
  console.log("执行一次");
}

button.addEventListener("click", onClick);
button.addEventListener("click", onClick);          // 不会重复

button.addEventListener("click", () => onClick());  // 新函数,会重复

所以「明明绑了两次怎么只打印一次」和「明明只绑了一次怎么点了两下」,都可能跟这条规则加匿名函数有关。排查重复绑定的时候,先看是不是每次都创建了一个新函数。

事件对象:target 和 currentTarget 是两个东西

回调收到的参数是事件对象,最常用的几个:

list.addEventListener("click", (event) => {
  console.log(event.type);           // "click"
  console.log(event.target);         // 实际点到的那个元素
  console.log(event.currentTarget);  // 绑定监听的元素,这里就是 list

  // 鼠标相关
  console.log(event.clientX, event.clientY);   // 相对可视区域
  // 键盘相关
  console.log(event.key);            // "Enter"、"a"、"Escape"
});

target 是「真正被点的元素」,currentTarget 是「当前正在执行监听的那个元素」。因为事件会冒泡,点一个按钮,按钮、它的父元素、更外层元素上的监听都会依次执行,每一层里的 currentTarget 都不同,但 target 一直是那个按钮。

很多人写委托时用错,就出在这里:

// 想处理列表项点击,却判断成了外层容器
list.addEventListener("click", (event) => {
  if (event.currentTarget === list) return;   // 永远成立,等于没判断
});

// 正确:判断实际点到的东西
list.addEventListener("click", (event) => {
  const item = event.target.closest(".item");
  if (!item) return;                          // 点到了列表空白处
  console.log(item.dataset.id);
});

冒泡和捕获:事件走两遍

点击一个按钮,事件并不是「只给按钮」。它先从最外层往下传到按钮(捕获阶段),再从按钮往上回到最外层(冒泡阶段),最后到达目标本身。绝大多数监听默认在冒泡阶段执行,所以你会看到「点内层,外层也跟着触发」。

<div id="outer">
  <button id="inner">点我</button>
</div>

outer.addEventListener("click", () => console.log("outer 冒泡"));
inner.addEventListener("click", () => console.log("inner"));

// 点击按钮,输出:
// inner
// outer 冒泡

// 把 outer 的监听改成捕获阶段
outer.addEventListener("click", () => console.log("outer 捕获"), true);
// 点击按钮,输出:
// outer 捕获
// inner

回调里打印 event.eventPhase 能直接看出当前在哪个阶段:1 是捕获,2 是目标,3 是冒泡。调试「为什么外层先执行」的时候,看这个数字比读代码猜快。

两个方法经常被混用,其实差别很大:

stopPropagation:别往外传了

阻止事件继续冒泡或捕获。外层元素上的监听不会执行。它不是取消默认行为。

preventDefault:别做默认动作

阻止浏览器自带的动作,比如链接跳转、表单提交、右键菜单。事件照样冒泡,外层监听照样执行。

return false 不可靠

只有在 onclick 这类属性赋值方式里才有「阻止默认」的效果,用 addEventListener 时 return false 什么都不做。

我平时的用法:preventDefault 用在明确要拦住浏览器动作的地方(表单提交、链接跳转);stopPropagation 尽量少用,因为它会让外层监听「莫名失效」,排查时很难想到是内层拦了。真需要隔离,优先改结构或者用捕获阶段统一处理。

事件委托:一个监听管一整片

回到开头的问题。委托的做法是不给每个按钮绑,而是绑在它们共同的父容器上,利用冒泡,从 event.target 找到真正点中的元素:

<ul id="order-list">
  <li class="row">
    <span class="name">订单 A</span>
    <button class="delete" data-id="1">删除</button>
  </li>
</ul>
const list = document.getElementById("order-list");

list.addEventListener("click", (event) => {
  const btn = event.target.closest(".delete");
  if (!btn) return;                    // 点的不是删除按钮,直接退出

  const id = btn.dataset.id;
  deleteOrder(id);
});

好处有三个:新渲染的行自动生效,不用重新绑;监听只有一个,内存和绑定成本都低;删除行时监听还在,不需要维护解绑逻辑。这就是开头两个问题一起被解决的原因。

但委托有几个前提,不知道就会写错:

前提说明
事件要冒泡focus、blur 不冒泡,得用 focusin、focusout 代替;mouseenter、mouseleave 也不冒泡
父容器要一直存在监听绑在会被替换掉的容器上,替换后监听就没了
要判断边界用 closest 找目标,找不到就退出,否则点空白处也会触发

closest 从当前元素开始往上找,返回第一个匹配的祖先(也匹配自己)。它比一层层判断 parentNode 稳,因为按钮里面可能还套着图标或文字,点到的是内层元素。

如果容器内部还嵌了别的可复用组件,closest 可能一路找到容器外面去。补一句 !list.contains(btn) 再退出,成本很低,能省掉一类很怪的误触。

解绑和内存:为什么点了没反应,或者触发两次

解绑必须传「同一个函数引用」,这是最常见的坑:

// 解不掉:两个箭头函数不是同一个
element.addEventListener("click", () => doSomething());
element.removeEventListener("click", () => doSomething());

// 正确:存起来,绑和解用同一个
function handleClick() {
  doSomething();
}
element.addEventListener("click", handleClick);
element.removeEventListener("click", handleClick);

参数也要一致。addEventListener("click", fn, true) 注册在捕获阶段,解绑时也得传 true,否则解不掉。

新的写法是 AbortController,适合一次解绑多个监听:

const controller = new AbortController();

element.addEventListener("click", onClick, { signal: controller.signal });
element.addEventListener("keydown", onKeydown, { signal: controller.signal });

// 组件卸载时一次性全部移除
controller.abort();

另一个常见来源是「重复绑定」:组件重复初始化、页面切回来又执行了一遍初始化代码,同一个元素上叠了多个相同监听,于是点一次发两次请求。排查时可以在监听里打印一段固定字符串,看到打印几次就知道绑了几次。防御性做法是初始化前先判断,或者用委托把监听收敛到一个地方。

现代框架里,addEventListener 通常由框架代为管理,自己在 useEffect 或生命周期里加的原生监听,一定要在清理函数里解绑,否则组件切走之后它还在跑,甚至操作已经销毁的节点。

高频事件:滚动、输入和窗口缩放

scroll、resize、input、mousemove 这类事件一秒能触发几十上百次。在回调里做重活(读布局、发请求、改大量 DOM),页面就会卡:

// 每次滚动都读一次布局,滚动明显发涩
window.addEventListener("scroll", () => {
  const top = document.documentElement.scrollTop;
  header.style.transform = "translateY(" + Math.min(top, 60) + "px)";
});

两种常见处理。节流:固定时间间隔最多执行一次,适合滚动、拖拽这种「持续发生、只要最新状态」的场景。防抖:停下来之后再执行,适合搜索输入这种「等用户输完再发请求」的场景。实现都靠闭包存定时器,具体写法在闭包那篇里。

还有两个细节:

滚动的监听加 { passive: true },告诉浏览器这个回调不会阻止滚动,滚动更顺。很多移动端卡顿就是这个参数没加。
在回调里读 getBoundingClientRect、scrollTop 会触发布局计算;连续读写 DOM 会来回触发重排。把读和写分开,或者用 requestAnimationFrame 合并到下一帧。
能不用监听就不用。吸顶、进度条这类效果,很多可以用 CSS 的 position: sticky 或滚动驱动的动画实现,成本比 JS 低。

关于 passive 还有个现状:Chrome 对 window、document 上的 touchstart、touchmove 默认就是 passive。老代码在这两个元素上做自定义滚动、调用 preventDefault,会发现不生效,控制台出现「Unable to preventDefault inside passive event listener」的警告。要么显式传 { passive: false },要么改用 touch-action 这类 CSS 方案。

完整场景走查:200 行订单表格的点击是怎么失控的

需求:后台订单列表,一页 200 行,每行四个操作(改价、备注、删除、展开明细),表头有全选,支持加载更多和每 30 秒自动刷新。原生 JS 加模板字符串渲染,没有框架。

第一版沿用开头那种修法:每次渲染完,重新给所有按钮绑一遍。

function bindRows() {
  tbody.querySelectorAll(".delete").forEach((btn) => {
    btn.addEventListener("click", () => removeOrder(btn.dataset.id));
  });
  tbody.querySelectorAll(".edit").forEach((btn) => {
    btn.addEventListener("click", () => openEdit(btn.dataset.id));
  });
}

function render(rows) {
  tbody.innerHTML = rows.map(rowHtml).join("");
  bindRows();
}

一页 200 行、四个按钮就是 800 个监听,创建时慢一点还能接受。问题出在「加载更多」:为了省事,追加数据后调用的还是 render(全部数据),而旧行早就在 DOM 里,重新绑一遍等于给旧行再加一套监听。加载到第 5 页、合计 1000 行时,第一页那 200 行每行已经有 5 个删除监听。运营批量删 200 行,点一次确认,前端发出 1000 个请求,浏览器 6 个连接跑满,接口开始返回 429,页面卡了七八秒。

第二个症状是内存。每个监听闭包都捕获了按钮、行和整条订单对象,翻到第 20 页时 Memory 快照里的堆从 50MB 涨到 200MB 上下,切页明显变卡。

改回委托,只需要两个监听:一个处理点击,一个处理勾选。行内按钮用 data-action 标动作,用 closest 找目标:

tbody.addEventListener("click", (event) => {
  const action = event.target.closest("[data-action]");

  if (action && tbody.contains(action)) {
    const row = action.closest("tr");
    const id = row && row.dataset.id;
    if (!id) return;

    if (action.dataset.action === "delete") askDelete(id, row);
    if (action.dataset.action === "edit") openEdit(id);
    if (action.dataset.action === "detail") toggleDetail(row);
    return;
  }

  // 没点按钮,才当成行选中;输入框、链接不处理
  if (event.target.closest("input, label, a")) return;

  const row = event.target.closest("tr");
  if (row) toggleSelect(row);
});

这段代码解决的不只是重复绑定,四个细节都在里面:点按钮里的图标时,target 是图标,closest 能找到按钮;点全选 checkbox 时,closest("input, label") 直接退出,不会顺带把行选中;点行内空白和点行本身都算选中;tbody.contains(action) 防止嵌套组件里的同名按钮被误判。

自动刷新还有一个坑:每 30 秒重渲染一次,用户正在行内编辑备注,输入框会被冲掉。加一行判断就够:

function autoRefresh() {
  if (tbody.contains(document.activeElement)) return;  // 正在编辑,跳过这一轮
  loadPage(currentPage);
}

改完的数据:整张表固定 2 个监听,加载到 5000 行也不变;批量删除 200 行从 1000 个请求降到 1 个;内存不再随翻页上涨。真正省下来的不是绑定那点时间,而是「同一个动作被触发多次」这类线上事故。

错误现象对照

事件问题有个共同点:大多数不报错。按现象反查,比通读绑定代码快得多。

现象真实原因第一步查什么
新渲染出来的行,点什么都没反应 绑定时元素还没进 DOM,或者只给第一页绑过 Elements 里选中该行,Console 用 getEventListeners 看(Chrome 专用),再确认绑定发生在渲染之后
点一次删除,Network 里出现 5 条相同请求 重复绑定。加载更多时给旧行又绑了一遍 在回调入口打印一行固定字符串,数打印次数;搜 querySelectorAll 附近的绑定代码
点按钮中间的图标没反应,点边缘有反应 用 matches 判断了 event.target,实际点到的是内部 span 或 svg 打印 event.target.tagName 和 className,确认落点
点弹窗里的输入框,弹窗被关掉了 「点击外部关闭」只监听了 document,没判断点击位置是否在弹窗内 打印 event.target,检查 panel.contains(event.target) 是否为真
点全选,行选中状态乱了 checkbox 的 click 冒泡到了行选择逻辑,一个动作被处理了两次 在行处理函数开头加 closest("input, label") 的判断,再点一次
表单点提交后页面刷新,参数跑到地址栏 没调用 preventDefault,按钮默认 type 是 submit Network 里看有没有 document 请求,URL 上有没有多出 ? 和参数
页面切走再回来,内存一直涨 监听没解绑,闭包持有 DOM 和大对象 Memory 快照对比两次,再数一下监听数量,重点查组件卸载时的清理函数

最容易浪费时间的是第一行。没有报错,人会先去怀疑样式、层级、遮罩,最后才想到监听。实际排查顺序应该反过来:先确认元素在不在、有没有监听,再去看视觉。

边界与代价:什么时候别委托,什么时候别拦

委托好用,但不是所有事件都能委托。不冒泡的事件绑到父容器上收不到,比如 focus、blur(改用 focusin、focusout)、mouseenter、mouseleave(改用 mouseover、mouseout 并判断边界)。用 scroll 也算半个例外:它不冒泡,但在捕获阶段能监听到,所以 addEventListener("scroll", fn, true) 是可行的,只是容易误伤整棵子树。

代价方面,委托每次触发都要做一次 closest 向上查找。点击、键盘这种每秒个位数的事件完全感觉不到,1000 行的表也没问题;但 mousemove 一秒上百次、DOM 又嵌了十几层,就不适合把逻辑全塞进一个顶层委托里。判断标准很简单:每秒超过 30 次的事件,不要在大容器上做复杂委托。

stopPropagation 的代价常被低估。它不影响同一个元素上的其它监听,那是 stopImmediatePropagation 才做的事;但它会让所有外层监听收不到,包括埋点、外层组件的点击外部关闭、第三方库的全局处理。表现就是「埋点突然少了」「弹窗关不掉了」,而且很难联想到是内层某一行拦住的。能用 target 判断解决的,就别拦冒泡。

还有几个容易忽略的成本:

  • once: true 只给一次机会。第一次触发时条件不满足(比如用户先拖了一下而不是点击),后面就永远不会再触发。
  • passive: true 是承诺,不是优化开关。加了之后 preventDefault 不生效,自定义滚动、下拉刷新手势都会失灵。
  • 监听本身很便宜,贵的是闭包捕获。一个处理函数捕获了 10MB 的接口响应,组件切十次就是 100MB,解绑也救不回来,得把引用一起放掉。
  • 输入类事件要考虑输入法。中文拼音还没上屏时 input 也会触发,防抖 300ms 仍可能发出无意义的请求,最好同时监听 compositionstart 和 compositionend,组合期间不发请求。

给几条判断标准:20 行以上、会动态增删的列表,用委托;10 行以内、结构固定,直接绑也无可厚非;同一个容器上超过 3 个监听,合并成一个带 data-action 的更清楚;滚动、拖拽用节流或 requestAnimationFrame 合并;层叠很深的嵌套组件里,优先在最近的公共容器上委托,别一路委托到 document。

小结

统一用 addEventListener:能绑多个、能解绑、能选阶段。第三个参数可以控制捕获、只执行一次、被动监听。
target 是实际点到的元素,currentTarget 是绑定监听的元素;委托里用 closest 找目标,找不到就退出。
stopPropagation 拦冒泡,preventDefault 拦默认行为,两者别混用;return false 在 addEventListener 里没用。
列表交互优先用委托,新增元素自动生效;解绑要传同一个函数引用,多个监听可以用 AbortController 一起清。
高频事件用节流防抖,滚动监听加 passive,读写 DOM 分开做。

今天就能自己验的几件事:

  1. 在 Chrome 控制台用 getEventListeners 查一个按钮,确认它身上到底挂了几个 click;这是 DevTools 的命令,不是页面里能用的 API。
  2. 写一个 100 行的列表,用委托绑定,再动态插入 20 行,确认新行不用重新绑也能点。
  3. 把某处 matches 换成 closest,专门点按钮内部的 span,复现失效再修好。
  4. 给 scroll 监听加上 { passive: true },用 Performance 面板对比滚动时的 Layout 次数。
  5. 验证一件事:stopPropagation 不会阻止同一元素上的其它监听,只有 stopImmediatePropagation 会。

这一组十二篇到这里就结束了,确实没有下一篇。硬要给一个「接下来读什么」,我的建议是先花半小时把闭包和this 与 class再翻一遍:今天写的委托回调、节流防抖里的定时器,全靠这两样撑着,读完和读透是两回事。补完底子再进浏览器那组,先读事件循环与任务队列,再啃渲染管线;那两篇会解释很多「代码没写错但页面就是慢」的现象,跟这篇的高频事件处理正好接上。