刚开始写交互,很容易遇到两种问题:一种是对着页面写了一堆 querySelector,运行起来全是 null,查半天发现脚本放在了元素前面;另一种是给列表里每个项都绑一个点击事件,数据一多页面就卡,删了又加之后事件还重复触发。这两个问题都指向同一件事:你得知道 DOM 到底是什么、事件是怎么走的。

这篇讲 DOM 和 BOM。DOM 是页面内容变成的那棵对象树,代码通过它增删改查页面;BOM 是浏览器暴露给脚本的一组对象,管地址栏、历史、屏幕、本地存储这些「页面之外」的东西。读完你能做到:安全地找到和改节点,用事件委托代替一堆重复监听,知道哪些写法会让页面变卡。

先看整体关系:

代码、DOM 与 BOM 的关系
BOM:window、location、history、navigator、localStorage
DOM:document 及其下的元素树
页面:浏览器根据 DOM 和样式画出来的界面

DOM 是什么,为什么你会拿到 null

DOM(Document Object Model,文档对象模型)是浏览器把 HTML 解析之后生成的对象树。每个标签、每段文字都是对象,彼此有父子关系,根节点是 document。它不是「屏幕上的像素」,而是「页面结构的程序版本」。你改 DOM,浏览器再根据新的结构重新排版和绘制。

回到开头的 null:脚本执行时,浏览器还没解析到它后面的元素,树里自然没有,document.querySelector('.list') 就返回 null,接着访问 .style 直接报错。解决办法不是到处加 if 判断,而是把脚本放到 <body> 末尾,或者给脚本加 defer,让它在文档解析完成后再执行。这是最常见的「代码没错但就是找不到元素」。

查找节点:先拿到,再动手

日常用得最多的是这几种:

写法返回什么注意点
document.querySelector('.item')第一个匹配的元素,没有就 null最常用,选择器写法跟 CSS 一样
document.querySelectorAll('.item')所有匹配的元素(静态 NodeList)拿到之后页面再加元素,它不会自动变长
document.getElementById('app')单个元素按 id 找,速度直接,不用写选择器
document.getElementsByClassName('item')HTMLCollection是「活的」,页面变化会实时反映,循环时容易踩坑

「静态」和「活的」这个差别很实际。下面这段会死循环,因为 getElementsByClassName 每次取 length 都是新的:

const items = document.getElementsByClassName('item');
for (let i = 0; i < items.length; i++) {
  const div = document.createElement('div');
  div.className = 'item';
  document.body.appendChild(div); // 每次循环 length 都加一
}

换成 querySelectorAll 得到静态列表,或者先把长度存下来,就不会出这个问题。这类 bug 不常见,但一旦出现很难一眼看出来。

创建、修改、删除:一个列表渲染的真实写法

改内容有三条路,各有代价:

  • textContent:只当纯文本处理,最安全,用户输入里有 <script> 也不会被执行。
  • innerHTML:按 HTML 解析,写起来快,但把用户输入拼进去就有 XSS 风险,而且每次赋值都要重新解析一遍,数据多时很慢。
  • 创建节点再插入:createElement 加 appendChild,可控、安全,但要写更多代码。
// 推荐写法:数据来自接口,先用 fragment 拼好再一次性插入
const list = document.querySelector('#order-list');
const fragment = document.createDocumentFragment();

for (const order of orders) {
  const li = document.createElement('li');
  li.className = 'order-item';

  const title = document.createElement('span');
  title.textContent = order.title; // 用户内容一律用 textContent

  const status = document.createElement('span');
  status.className = 'status ' + order.status;
  status.textContent = order.statusText;

  li.append(title, status);
  fragment.appendChild(li);
}

list.replaceChildren(fragment); // 一次性替换,避免多次重排

反例是 list.innerHTML += ... 写在循环里。它每次都在「读旧 HTML、解析新字符串、重建整棵子树」,十条数据可能看不出,一千条就是明显的卡顿。这个坑在渲染消息列表、日志列表时特别常见。

用 innerHTML 拼接任何来自用户或接口的字符串,都要先转义,或者干脆用 textContent。这不是「注意一下」的问题,是能被利用的安全漏洞。

事件:绑定方式与事件对象

页面要能响应操作,靠的是事件。最常用的绑定方式是 addEventListener:

const button = document.querySelector('#submit');

button.addEventListener('click', (event) => {
  console.log(event.type);        // click
  console.log(event.target);      // 实际被点的元素
  console.log(event.currentTarget); // 绑定监听器的元素
});

事件对象里有几个容易混淆的属性:target 是「事件真正发生的元素」,可能是一个按钮里的图标;currentTarget 是「当前执行监听器的元素」,也就是你绑定的那个。做事件委托时这个差别很关键。

绑定方式上,addEventListener 可以为同一个事件绑多个处理函数,也可以用 removeEventListener 移除;而 element.onclick = fn 只能保留最后一个,重复赋值会覆盖前一个。后者在老代码里常见,排查「为什么我的回调没执行」时要留意。

还有两个常用选项:once: true 让监听器只触发一次,适合「首次点击后就不再需要」的场景;passive: true 告诉浏览器这个监听器不会调用 preventDefault,浏览器就能放心地滚动而不用等你执行完,滚动性能会更好。给 touchmove、wheel 绑监听时,这个选项值得加。

冒泡、捕获与事件委托

点击一个按钮,事件并不是只在按钮上发生。它先从 document 往下走到目标(捕获阶段),再从目标往上回到 document(冒泡阶段)。绝大多数事件都能冒泡,这也是事件委托的基础。

事件传播的三个阶段
捕获:从外往里
目标:事件发生的元素
冒泡:从里往外

事件委托就是利用冒泡:不给每个子项绑事件,而是在共同的父元素上绑一个。真实场景里,列表项是动态渲染的,今天十条明天一千条,给每一项绑监听既浪费又容易漏绑。

const list = document.querySelector('#todo-list');

list.addEventListener('click', (event) => {
  const item = event.target.closest('.todo-item');
  if (!item) return; // 点到了列表空白处

  const action = event.target.dataset.action; // 'toggle' 或 'delete'
  if (action === 'delete') {
    item.remove();
  } else if (action === 'toggle') {
    item.classList.toggle('done');
  }
});

这段代码只绑了一个监听器,却能处理任意数量的列表项,包括后来新增的。用 closest 是因为用户可能点到项里的文字或图标,需要往上找到真正的列表项容器。

事件委托不是万能的。像 focus、blur 这类不冒泡的事件就不能直接委托;有些场景需要拿到精确的 event.target,委托反而增加判断成本。判断标准是「子项多不多、是否动态新增」,不是「一律用委托」。

BOM:浏览器本身也有一组接口

DOM 管页面内容,BOM(Browser Object Model,浏览器对象模型)管浏览器本身。它不是一份严格的规范,而是各家浏览器实现出来的一套约定,日常用到的主要是这些:

  • window:全局对象,也是所有 BOM 接口的入口。页面里的全局变量、定时器、事件监听都挂在它上面。
  • location:地址栏。可以读 href、pathname、search、hash,也可以赋值跳转、调用 reload()、assign()。
  • history:浏览历史。pushState 可以在不刷新页面的情况下改地址,做单页应用的路由就靠它;back()、forward() 回退前进。
  • navigator:浏览器信息,比如语言、是否在线、剪贴板接口。要提醒的是,靠 userAgent 判断浏览器并不可靠,浏览器可能伪装或冻结这个字符串,特性检测才是更稳的做法。
  • screen:屏幕尺寸。它和窗口尺寸不是一回事,窗口可能只占屏幕的一部分,做响应式时应该看 window.innerWidth 而不是 screen.width。
  • localStorage:本地存储,后面有专门一篇讲存储时会细说。这里先记住它是同步 API,读写会阻塞当前线程,别在渲染关键路径上大量读写。

为什么频繁操作 DOM 会卡

「少操作 DOM」这句话被说烂了,但原因值得说清楚:每次改 DOM 都可能让浏览器之前算好的样式和布局失效,下一次读取尺寸或下一帧渲染时就得重算。改得越碎、越频繁,重算次数越多。真正的成本不在「改」这个动作,而在它引发的连锁反应。

实践里有几条能立刻见效的做法:

  • 批量插入:用 DocumentFragment 或先离线拼好,再一次性挂到页面上,避免每插一条都触发一次布局。
  • 读写分离:先集中读尺寸,再集中写样式。混着写会让浏览器反复做同步布局,原理在浏览器渲染管线里讲过。
  • 用 class 切换代替逐条改样式:改 element.classList.add('active') 通常比连续改五个 style 属性好,样式规则交给 CSS,浏览器合并起来处理。
  • 数据量大时考虑虚拟滚动,但别过早优化。几百条以内直接渲染通常够用,虚拟滚动带来的滚动定位、无障碍、打印问题都是真实成本。
  • 监听器要及时移除:组件销毁、页面切换时,忘了 removeEventListener 或没清理定时器,会留下引用,长时间运行的页面内存会慢慢涨。

还有一个常被忽略的点:DOM 节点本身是有成本的。一个隐藏的、巨大的列表如果一直挂在文档里,即使 display: none,节点和监听器仍然占内存,事件委托的父容器也仍然在。该删除时要真的删除,不要只藏起来。

走一遍真实排查:删除按钮偶尔删错一条

一个消息中心页面:列表每五秒轮询一次,每条消息右边有删除按钮。上线后反馈「删除会删错」,删第 3 条,消失的是第 5 条;有时候点删除完全没反应。这算典型的 DOM 操作问题,但排查过程并不直接。

第一次判断:接口传错 id。最像是「前端把 id 传串了」。于是在点击回调里打日志,把请求参数和这一行的文字一起打出来,发现传出去的 id 和用户点的那条对不上,但接口本身没错。到此可以确认问题在前端「哪条记录对应哪个 id」的映射上。

第二次判断:轮询把节点换掉了。代码是每次轮询用 innerHTML 整体重建列表,重建后行数变了(有的消息被读掉就不返回了),而删除按钮上存的是 data-index,也就是渲染时的下标。用户看到的是「现在的第 3 行」,但那个 index 是三秒前那次渲染的下标,中间列表已经变过。下标不是身份,行号会漂移。

顺手排除一个怀疑。有人担心「列表重建后事件委托会失效」。试着重建成 100 行再点,删除依然能触发,说明委托监听绑在父容器上,子节点被替换不影响父容器上的监听。这个怀疑可以划掉,别在这里浪费时间去重新绑事件。

为什么有时候点了没反应。删除按钮里有一个小图标,用户点中的是图标本身。代码里写的是 event.target.dataset.id,图标上没有这个属性,拿到 undefined,于是什么都没发生,也不报错。正确做法是 event.target.closest('[data-id]'),从实际点到的元素往上找按钮。

怎么改的。把 data-index 换成接口返回的业务 id,点击时用 closest 拿按钮再读 id;轮询不再整体重建,而是按 id 做增删改,只更新变化的行;列表容器的滚动位置在更新前记下来,更新后还原。顺带解决了「正在输入时轮询把输入框内容清空」的问题。

这里的三个坑互不相干:下标不是身份、target 不是绑定元素、整体重建会丢状态。它们能同时存在于一个页面里,所以别指望找到一个「总原因」。

现象对照:DOM 相关的常见故障

你看到的现象更可能的原因第一步查什么
脚本里 querySelector 拿到 null,报 Cannot read properties of null脚本执行时目标节点还没被解析出来,常见于放在 <head> 里的同步脚本看脚本是不是在目标节点之前;改成放 body 末尾、加 defer,或放进 DOMContentLoaded
用 getElementsByClassName 遍历并往同类元素里追加,页面直接卡死它返回的是实时集合,边加边变长,循环条件永远成立换 querySelectorAll,或循环前先把 length 存成变量
点击没反应,控制台也没有报错点到的是按钮里的图标或文字,event.target 不是你以为的那个元素,取属性取到 undefined先打印 event.target.tagName,再改用 closest 往上找
点击带图标的按钮时,表单整页刷新<button> 在不写 type 时默认是 submit,触发了表单提交给按钮显式写 type="button";确实要提交时再处理 submit 事件
从 localStorage 取出来的数字变成了字符串,比较结果不对存储只能存字符串,取出来需要自己转换确认读写两端都做了 JSON.stringify 与 JSON.parse
删掉元素后,某个逻辑还会被执行监听器绑在 window、document 或长期存在的父容器上,节点没了监听还在查有没有在全局对象上绑监听,组件销毁时是否成对移除

把这张表当成排查顺序:先确认「元素在不在」,再确认「拿到的元素对不对」,最后才怀疑业务逻辑。倒过来做,通常会在业务代码里绕很久。

这些做法的边界与代价

  • 事件委托只对会冒泡的事件有效。focus、blur 不冒泡,要委托得换成 focusin、focusout。另外用了 Shadow DOM 时,外部拿到的 event.target 会被重定向成宿主元素,需要 composedPath() 才能看到里面的真实目标,这一点在组件库场景里很常见。
  • 委托的判断有成本。每次点击都要从目标往上找匹配,列表项结构很深时,这个判断比「直接绑在按钮上」贵。子项数量不多、结构固定时,直接绑反而更简单。
  • DocumentFragment 只在插入前有意义。插进文档后 fragment 会被清空,不能拿它当容器继续操作;挂在 fragment 上的事件也不会冒泡到文档,因为它不在文档树里。
  • 局部更新的代码量更大。按 id 做增删改要维护「哪一行对应哪条数据」,比整体重建麻烦得多,也更容易写错。数据量小、更新不频繁时,整体重建完全够用,别为了「性能」把简单逻辑做成一个小型框架。
  • localStorage 是同步的。读写会占用主线程,几 MB 的数据一次性读写能明显卡一下;它也不适合存频繁变化的大对象。

当天就能做的四件事

  1. 在 <head> 里写一段同步脚本,用 document.querySelector('body') 取节点,看是不是 null;把这段脚本移到 body 末尾再加 defer,观察区别。
  2. 写一个列表,用事件委托绑点击,在回调里打印 event.target.tagName 和 event.currentTarget.tagName,然后点按钮里的图标,看两个值分别是谁。
  3. 用 DocumentFragment 插入 1000 个列表项,和循环里逐个 appendChild 对比耗时(用 console.time)。
  4. 给一个按钮绑监听,然后把这个按钮从文档里移除,再在控制台手动触发点击事件,看监听是否还执行;再重复一次,这次把监听绑在 document 上,对比结果。

小结与下一篇

DOM 是页面结构的对象树,代码通过查找、创建、修改、删除节点来改页面;事件从外到内捕获、从内到外冒泡,动态列表优先用事件委托;BOM 提供 window、location、history、navigator、screen、localStorage 这些浏览器级接口。操作 DOM 本身不慢,慢的是它触发的反复布局和绘制,以及没清理干净的监听器和节点。

下一篇读常用浏览器 API。原因是这篇里「用 scroll 监听算位置」「用轮询判断数据变化」这类做法,在下一篇有更省事的替身:滚动可见性用 IntersectionObserver,DOM 变化用 MutationObserver,取数据用 fetch。你现在手写的那些监听和判断,大部分可以换成浏览器自带的能力。

如果你更想先弄清「为什么改完 DOM 没有立刻显示」,回看队列与事件循环;想弄明白「为什么批量插入比逐条插入快」,读浏览器渲染管线里的布局一节。