DOM & BROWSER PLATFORM

让页面听得懂你的代码

JavaScript 真正的舞台不在控制台,而在浏览器。DOM 把一份 HTML 文档变成可查询、可修改的节点树; 事件系统把一次点击变成可以编程的信号;表单、存储与观察器则把浏览器的原生能力交到脚本手里。 这一页从节点类型讲起,穿过捕获与冒泡,走到拖拽排序、懒加载与可复用弹窗,把“操作页面”拆成一整套可推演的方法。

4 个章节 17 个知识点 3 个交互演示 建议阅读 100 分钟
Chapter 01

DOM 基础

DOM 是浏览器对 HTML 文档的内存表示。先认清这棵树的形状与节点类型,再学会查询、读写与增删,页面才真正变成可以编程的数据结构。

1.1

DOM 树与节点类型

入门

DOM(Document Object Model)不是一段 HTML 字符串,而是浏览器解析文档后建立的一棵节点树。 树根是 document,向下依次是 html、head 与 body, 再往下是具体元素、文本与注释。每个节点都是对象,拥有属性与方法,脚本通过这层对象接口访问页面, 而不是去修改原始 HTML 文本。

节点用 nodeType 区分:1 表示元素,3 表示文本,8 表示注释,9 表示文档,11 表示文档片段。 children 只包含元素子节点,childNodes 则包含文本与注释; parentNode、firstChild、nextSibling 这些指针把整棵树串起来。 HTML 里的换行与缩进同样会产生文本节点,这正是“遍历结果总比预期多几项”的常见原因。

查询得到的 Element 与 NodeList 都活在这棵树上,但可用 API 并不相同: 文本节点没有 querySelector,元素节点也不该用 nodeValue 去读文本。 动手前先确认手里拿到的是元素还是节点,能省掉大量判空与类型判断。

递归遍历并识别节点类型

// 用递归遍历真实 DOM 子树,观察节点的不同类型
function walk(node, depth) {
  const pad = '  '.repeat(depth);
  const type = node.nodeType;
  let label = '';

  if (type === Node.ELEMENT_NODE) {
    label = '元素 <' + node.tagName.toLowerCase() + '>';
  } else if (type === Node.TEXT_NODE) {
    label = '文本 "' + node.nodeValue.trim().slice(0, 12) + '"';
  } else if (type === Node.COMMENT_NODE) {
    label = '注释';
  } else {
    label = '其他类型 ' + type;
  }

  // 纯空白的文本节点只会干扰阅读,直接跳过
  if (type === Node.TEXT_NODE && !node.nodeValue.trim()) return;
  console.log(pad + label);

  // childNodes 含文本与注释,children 只含元素
  for (let i = 0; i < node.childNodes.length; i++) {
    walk(node.childNodes[i], depth + 1);
  }
}

console.log('document 的 nodeType 是', document.nodeType);       // 9
console.log('根元素是', document.documentElement.tagName);        // HTML
walk(document.body, 0);

// 常见常量:1 元素、3 文本、8 注释、9 文档、11 文档片段

为什么遍历结果里有空白文本节点。HTML 中的换行、缩进在解析后都会成为 nodeType = 3 的文本节点。需要按结构遍历时用 children;需要完整还原内容时用 childNodes,并记得过滤空白。

1.2

查询元素:从 id 到选择器

入门

查询元素的 API 大致分两代。getElementById、getElementsByClassName、 getElementsByTagName 属于早期接口,调用简单、开销低,但返回的是动态集合; querySelector 与 querySelectorAll 接收完整的 CSS 选择器,表达力强, 返回静态结果,是现代代码的首选。

静态与动态的差别非常实际。querySelectorAll 返回的 NodeList 是查询那一刻的快照, 之后增删节点都不会改变它的长度;getElementsByClassName 返回的 HTMLCollection 是实时的, 每次访问 length 都会重新计算。若一边遍历一边删除节点,用动态集合极容易漏掉元素。

查询还应尽量缩小作用域:先在容器上取一次引用,再在容器内调用 querySelector, 比每次从 document 全局搜索更快,也能避免误选其它区域的同名元素。 选择器写错会抛出 SyntaxError,拼接选择器时尤其要小心。

API返回结果是否实时适用场景
getElementByIdElement 或 null单次查找唯一 id,速度最快
getElementsByClassNameHTMLCollection实时需要跟随 DOM 变化
getElementsByTagNameHTMLCollection实时按标签批量处理
querySelectorElement 或 null单次查找复杂选择器,现代首选
querySelectorAllNodeList(静态)快照批量遍历,可直接 forEach

静态快照与动态集合

// 现代查询:querySelector 接收任意 CSS 选择器
const first = document.querySelector('.content .topic');
const all = document.querySelectorAll('.topic');          // 静态 NodeList
const live = document.getElementsByClassName('topic');    // 动态 HTMLCollection

console.log('静态集合长度', all.length);
console.log('动态集合长度', live.length);

// 静态集合是快照,之后 DOM 变化不影响它
const snapshot = document.querySelectorAll('li');
// 动态集合每次访问 length 都重新计算
const dynamic = document.getElementsByTagName('li');

const li = document.createElement('li');
document.body.appendChild(li);
console.log('快照长度仍是', snapshot.length);
console.log('动态长度变成', dynamic.length);
li.remove();

// 非法选择器会抛 SyntaxError,应放在可捕获的位置
try {
  document.querySelector('div[');
} catch (error) {
  console.log('选择器错误:', error.name);
}

// 先取容器再向下查找,作用域更小、性能更稳
const scope = document.querySelector('main');
if (scope) {
  const links = scope.querySelectorAll('a');
  console.log('main 内链接数', links.length);
}

查询结果可能为空,querySelector 与 getElementById 找不到时返回 null,直接读属性会报错。习惯性写成 if (!el) return;,比事后排查空引用省事得多。

1.3

读写内容与属性

进阶

读取内容有三个层次:textContent 返回节点下的全部纯文本; innerHTML 返回序列化后的 HTML 字符串;innerText 受 CSS 影响, 会触发样式计算甚至重排,一般不建议在循环或高频回调里使用。

写入时的安全边界必须分清。textContent 把输入当作纯文本,尖括号会被自动转义, 天然免疫脚本注入;innerHTML 会把字符串解析成真实节点,任何用户可控的内容直接拼进去, 都可能形成 XSS。安全与便利之间没有折中,只有明确的信任边界。

属性操作优先使用专用 API:classList 增删类名不会覆盖其它类, dataset 负责 data-* 的驼峰映射,style 只操作内联样式且属性名用驼峰。 getAttribute / setAttribute 适合自定义属性;而 checked、value 这类会发生“属性与属性值不同步”的成员,应当直接读写 property,而不是 attribute。

内容、类名、数据属性与样式

// 读取内容:textContent 最安全,innerHTML 返回序列化结果
const title = document.querySelector('.page-hero h1');
if (title) {
  console.log('纯文本:', title.textContent.trim());
  console.log('HTML 长度:', title.innerHTML.length);
  console.log('渲染后文本:', title.innerText.trim());
}

const box = document.createElement('div');

// 写入纯文本:尖括号被转义,用户输入不会变成标签
box.textContent = '<script>alert(1)</script>';
console.log(box.innerHTML);        // 输出实体,而不是可执行脚本

// 写入 HTML:字符串会被解析成真实节点,只能用于可信内容
box.innerHTML = '<strong>可信内容</strong>';

// classList:增删类名不会覆盖其它类
box.classList.add('note', 'note--tip');
box.classList.toggle('is-hidden', true);
box.classList.replace('note--tip', 'note--info');
console.log([...box.classList].join(' '));

// dataset:data-user-id 对应 dataset.userId
box.dataset.userId = '42';
console.log(box.dataset.userId);              // "42"

// style:只写内联样式,属性名使用驼峰
box.style.padding = '12px';
box.style.backgroundColor = '#faeee7';
console.log(box.getAttribute('style'));

// 通用属性读写
box.setAttribute('aria-hidden', 'false');
console.log(box.hasAttribute('aria-hidden')); // true
box.removeAttribute('aria-hidden');

innerHTML 不是模板引擎。它会把字符串里的 <img onerror=...> 真正插入文档并执行。只要数据来自用户、URL 参数或第三方接口,就必须先转义,或改用 createElement 配合 textContent 组装。

1.4

创建、插入与删除节点

进阶

创建节点用 document.createElement,文本用 createTextNode, 克隆用 cloneNode(deep)。插入方法有一组语义清晰的成员:append 与 prepend 处理子节点,before 与 after 处理兄弟位置, replaceWith 替换自身,remove 删除自身。

批量插入时先拼进 DocumentFragment,再一次性挂载,只会触发一次布局。 如果直接在循环里把节点 append 到文档中的元素上,浏览器可能反复计算布局,节点一多就明显卡顿。 片段本身不在文档中,但它被插入时,其子节点会整体转移。

用模板字符串拼 HTML 很顺手,却绕过了转义。只要内容里有一丝用户输入,就必须严格转义, 或者改用 createElement 配合 textContent 组装。前者快,后者稳, 在安全边界上不要赌运气。

批量插入与安全转义

// 1. 创建并插入单个节点
const list = document.querySelector('.tag-row');
if (!list) return;

const chip = document.createElement('span');
chip.className = 'tag';
chip.textContent = '新增标签';
list.append(chip);

// 2. 批量插入:先拼进 DocumentFragment,最后只挂载一次
const fragment = document.createDocumentFragment();
const words = ['闭包', '原型', '事件循环', '渲染'];

for (let i = 0; i < words.length; i++) {
  const item = document.createElement('span');
  item.className = 'tag';
  item.textContent = words[i];
  item.dataset.index = String(i);
  fragment.append(item);
}
list.append(fragment);

// 3. 位置控制:before / after 相对兄弟节点
const badge = document.createElement('em');
badge.textContent = '已更新';
chip.after(badge);
list.prepend(chip);              // 移动已有节点,而不是复制

// 4. 删除
const firstTag = list.querySelector('.tag');
if (firstTag) firstTag.remove();

// 5. 用字符串拼 HTML 时必须转义用户输入
function escapeHtml(text) {
  const map = { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' };
  return text.replace(/[&<>"']/g, function (ch) { return map[ch]; });
}

const userInput = '<img src=x onerror=alert(1)>';
console.log(escapeHtml(userInput));

克隆与模板。cloneNode(true) 会复制整棵子树,但不会复制通过 addEventListener 绑定的事件监听器。需要复用结构时,常用 <template> 元素保存一段惰性 DOM,再克隆它的 content。

Chapter 02

事件系统

页面之所以“活”,是因为事件把用户动作变成了函数调用。理解绑定、传播与委托,才能写出既省资源又好维护的交互。

2.1

addEventListener 与解绑

入门

addEventListener 是唯一推荐的绑定方式:同一个元素可以绑定多个同类监听器,彼此不会覆盖; 第三个参数支持 capture、once、passive 与 signal, 把行为细节交给浏览器而不是我们手动记账。

解绑的前提是拿到同一个函数引用。匿名函数每次求值都会生成新对象, removeEventListener 传入一个“长得一样”的新函数不会有任何效果。 因此凡是需要解绑的场景,都应先声明具名函数,或把引用保存在变量里。

once: true 让监听器执行一次后自动移除;passive: true 承诺回调不会调用 preventDefault,滚动与触摸事件加上它可以显著减少主线程阻塞; AbortController 的 signal 则能一次性取消一整组监听器,组件销毁时尤其好用。

绑定、解绑与一次性监听

const button = document.querySelector('#themeToggle');
if (!button) return;

// 同一个函数引用重复绑定会被去重,只执行一次
function handleClick(event) {
  console.log('点击来源:', event.target.tagName);
}
button.addEventListener('click', handleClick);
button.addEventListener('click', handleClick);

// 匿名函数无法精确移除:这是两个不同的函数对象
button.addEventListener('click', function () { console.log('A'); });
button.removeEventListener('click', function () { console.log('A'); });

// 需要解绑时必须保存引用
const onResize = function () { console.log('窗口变化'); };
window.addEventListener('resize', onResize);
window.removeEventListener('resize', onResize);

// options:once 只执行一次
button.addEventListener('click', handleClick, { once: true });

// passive 表示不会调用 preventDefault,滚动更顺
window.addEventListener('scroll', function () {
  console.log('滚动位置', window.scrollY);
}, { passive: true });

// AbortController 可以一次性取消一组监听器
const controller = new AbortController();
window.addEventListener('pointermove', function () {
  console.log('指针移动');
}, { signal: controller.signal });

controller.abort();      // 之后 pointermove 不再触发

忘记解绑就是泄漏。给 window 或 document 绑定监听器后,若元素被移除而监听器仍在,回调会继续持有元素引用,内存无法回收,还可能访问到已脱离文档的节点。组件初始化与销毁要成对出现。

2.2

事件对象与默认行为

进阶

事件对象携带这次交互的全部信息。target 是实际触发的元素, currentTarget 是当前正在执行监听器的元素。在委托场景里两者经常不同: 点在按钮上,target 是按钮,currentTarget 仍是绑定监听器的容器。

preventDefault 阻止浏览器默认行为,比如链接跳转、表单提交、右键菜单, 但它不影响事件继续传播;stopPropagation 截断传播路径, stopImmediatePropagation 还会跳过同一元素上后续注册的监听器。 三者作用不同,不能互相替代。

eventPhase 表示当前相位:1 捕获、2 目标、3 冒泡。 鼠标事件还提供 clientX、pageX、button 与组合键状态; 键盘事件应当读取 event.key(语义字符)或 event.code(物理键位), 已废弃的 keyCode 不应再使用。

成员含义使用要点
target实际触发的元素可能是子节点,需 closest 上溯
currentTarget绑定监听器的元素委托中用它判断容器边界
eventPhase1 / 2 / 3目标阶段捕获与冒泡监听器都是 2
preventDefault()取消默认行为不阻止事件传播
stopPropagation()终止传播路径可能破坏上层事件委托
stopImmediatePropagation()终止传播并跳过同元素后续监听调试时最容易误伤

target、相位与两种阻止

const card = document.querySelector('.card');
if (!card) return;

card.addEventListener('click', function (event) {
  // target 是真正被点中的元素,可能是一个子节点
  console.log('target:', event.target.tagName);
  // currentTarget 是当前执行监听器的元素,也就是 card
  console.log('currentTarget:', event.currentTarget.className);
  // eventPhase:1 捕获、2 目标、3 冒泡
  console.log('eventPhase:', event.eventPhase);

  // 阻止默认行为,但不影响事件继续传播
  event.preventDefault();

  // 截断传播路径,需谨慎,可能破坏上层委托
  // event.stopPropagation();

  // 位置与组合键
  console.log(event.clientX, event.clientY, event.ctrlKey);
});

document.addEventListener('keydown', function (event) {
  if (event.key === 'Escape') console.log('准备关闭弹层');
  if (event.key === 'Enter' && event.target.matches('input')) {
    console.log('在输入框中按下回车');
  }
});

// 表单提交的默认行为是整页刷新,拦截它是前端校验的起点
const form = document.querySelector('form');
if (form) {
  form.addEventListener('submit', function (event) {
    event.preventDefault();
    console.log('已拦截提交');
  });
}

passive 与 preventDefault。浏览器在 passive: true 的监听器里会忽略 preventDefault 并给出控制台警告。移动端滚动卡顿的常见修复方式,就是把触摸与滚轮监听改成 passive,再用 CSS 处理真正的滚动锁定。

2.3

捕获、目标与冒泡

深入

一次点击的传播分三段:捕获从 window 一路向下直到目标元素的父级, 目标阶段在目标元素上执行,冒泡再从目标向上回到 window。 addEventListener 第三个参数为 true 时监听捕获阶段,默认监听冒泡阶段。

目标元素上的监听器不区分捕获与冒泡:两类监听器都在目标阶段按注册顺序执行, eventPhase 都是 2。这一点常被忽略,于是有人疑惑“为什么捕获监听器没有最先执行”—— 它确实执行了,只是目标阶段本来就不分方向。

传播路径在事件派发时就已经确定,路径上的每个节点都有机会处理。 stopPropagation 只是提前终止这条路径,并不会撤销已经执行过的监听器; 因此依赖冒泡的委托逻辑,完全可能被中间某一层随手写下的 stopPropagation 打断。

演示 A · 捕获与冒泡的真实顺序可交互

点击任意一层盒子,日志按浏览器真实的事件路径输出。勾选中间层的选项后再点内层,可以观察 stopPropagation 如何截断整条路径。

CLICK ANY LAYER
outer · 外层
middle · 中层
inner · 内层
点击任意一层盒子开始。

三个阶段的监听顺序

// 结构:<div id="outer"><div id="inner"></div></div>
const outer = document.querySelector('#outer');
const inner = document.querySelector('#inner');
if (!outer || !inner) return;

// 捕获阶段:从 window 自上而下到达目标父级
outer.addEventListener('click', function (event) {
  console.log('1. outer 捕获,phase =', event.eventPhase);
}, true);

// 目标阶段:捕获与冒泡监听器都按注册顺序执行,phase 都是 2
inner.addEventListener('click', function (event) {
  console.log('2. inner 捕获监听器,phase =', event.eventPhase);
}, true);
inner.addEventListener('click', function (event) {
  console.log('3. inner 冒泡监听器,phase =', event.eventPhase);
});

// 冒泡阶段:从目标自下而上回到 document
outer.addEventListener('click', function (event) {
  console.log('4. outer 冒泡,phase =', event.eventPhase);
});

// 完整路径:window → document → body → outer → inner → outer → body → ...
// 顺序只由传播模型决定,与监听器的书写顺序无关

不冒泡的事件。focus、blur、load、mouseenter、mouseleave 等不会冒泡,无法直接用于事件委托。需要委托时改用会冒泡的 focusin / focusout,或在捕获阶段监听。

2.4

事件委托

深入

事件委托利用冒泡:不给每个子项绑定监听器,而是在共同的祖先上绑定一个, 通过 event.target 与 closest 判断真正触发的是谁。 子项增删都不需要重新绑定,行为自动继承,这是它最本质的价值。

它同时解决了性能与内存问题。一个列表有一千项时,一千个监听器会占去可观内存, 绑定与解绑本身也有成本;一个委托监听器就把开销压到常数级。 对列表、表格、菜单这类结构高度重复的区域,它几乎总是更优解。

局限同样明确:不冒泡的事件无法委托;依赖 target 精确匹配的复杂交互容易误判; 在极深的 DOM 上频繁调用 closest 也有代价。此外,若中途有代码调用 stopPropagation,祖先上的委托会直接失效,这类问题排查起来非常隐蔽。

演示 B · 事件委托驱动的列表可交互

删除按钮没有单独绑定监听器:点击冒泡到 ul 后,由 closest 定位触发源。新增的条目自动拥有同样的行为。

  • 阅读 DOM 节点类型
  • 手写一次事件冒泡
  • 整理一份事件速查表
初始有 3 项,全部由委托处理。

一个监听器管理整张列表

const list = document.querySelector('#todoList');
if (!list) return;

// 只在共同祖先上绑定一次,子项增删无需重新绑定
list.addEventListener('click', function (event) {
  const trigger = event.target.closest('[data-action]');
  if (!trigger || !list.contains(trigger)) return;   // 点击空白处直接忽略

  const item = trigger.closest('li');
  if (!item) return;

  const action = trigger.dataset.action;
  if (action === 'remove') item.remove();
  if (action === 'toggle') item.classList.toggle('is-done');
});

// 动态创建的节点天然继承委托行为
function addItem(text) {
  const li = document.createElement('li');
  li.dataset.id = String(Date.now());
  li.innerHTML = '<span class="text"></span>' +
    '<button type="button" data-action="toggle">切换</button>' +
    '<button type="button" data-action="remove">删除</button>';
  li.querySelector('.text').textContent = text;   // 用户文本走 textContent
  list.append(li);
  return li;
}

addItem('阅读事件委托');

// closest 会向上查找,因此判断事件是否来自列表内部很有必要:
// 嵌套列表或外部元素都可能让委托逻辑误触发。

框架里的委托。React 早期把所有事件委托到 document,React 17 起改为委托到根容器,以减少与其它库的冲突。理解原生委托,就能解释合成事件里 stopPropagation 为什么有时“只挡住了 React 自己的冒泡”。

2.5

常用事件与频率控制

进阶

鼠标事件包括 click、dblclick、mousedown / mouseup、 mousemove,以及不冒泡的 mouseenter / mouseleave。 只是悬停变色时优先用 CSS :hover,确实需要逻辑计算再交给 JS。

键盘与输入事件要分清语义:keydown / keyup 描述按键动作, input 在值每次变化时立即触发,change 则在失焦或回车后触发。 实时校验用 input,最终确认用 change,两者的触发次数相差很大。

滚动与触摸是性能敏感区。scroll 触发频率极高,回调里不要直接读写布局, 应配合 requestAnimationFrame 合并处理,或声明 passive; 触摸、鼠标与触控笔可以用 pointer 事件统一处理, pointerType 会告诉你这次输入来自 mouse、touch 还是 pen。

类别代表事件触发时机注意事项
鼠标click、mousedown、mousemove指针操作mouseenter 不冒泡
键盘keydown、keyup按键动作使用 key 而非 keyCode
输入input、change值发生变化input 实时,change 延迟
表单submit、reset表单动作需 preventDefault 拦截
视图scroll、resize视口变化高频,需 rAF 或 passive
指针与触摸pointerdown、touchstart触摸或触控笔pointer 可统一多设备

输入、滚动与指针

const field = document.querySelector('.input');
const panel = document.querySelector('.card');
if (!field || !panel) return;

// input 每次值变化都触发,适合实时校验
field.addEventListener('input', function (event) {
  console.log('当前值:', event.target.value);
});

// change 在失焦或回车时触发,适合最终确认
field.addEventListener('change', function (event) {
  console.log('确认值:', event.target.value);
});

// keydown 可以阻止默认行为,键盘事件用 key 而不是 keyCode
field.addEventListener('keydown', function (event) {
  if (event.key === 'Enter') console.log('回车提交');
  if (event.key === 'Escape') event.target.blur();
});

// mouseenter / mouseleave 不冒泡,悬停样式优先写在 CSS 里
panel.addEventListener('mouseenter', function () {
  panel.classList.add('is-hover');
});
panel.addEventListener('mouseleave', function () {
  panel.classList.remove('is-hover');
});

// 滚动高频触发,用 rAF 合并回调
let ticking = false;
window.addEventListener('scroll', function () {
  if (ticking) return;
  ticking = true;
  requestAnimationFrame(function () {
    console.log('滚动位置', window.scrollY);
    ticking = false;
  });
}, { passive: true });

// pointer 事件统一鼠标、触摸与触控笔
panel.addEventListener('pointerdown', function (event) {
  console.log('指针类型:', event.pointerType);
});

高频事件的处理原则:先判断是否真的需要监听,能用 CSS 解决就不要写 JS;确实需要时用 rAF 合并、用 passive 减少阻塞、用防抖控制真正执行的次数。三者叠加,滚动与输入才不会拖慢页面。

Chapter 03

表单与浏览器能力

除了节点与事件,浏览器还提供了表单校验、地址管理、本地存储与逐帧动画。学会调用这些原生能力,很多功能不必依赖第三方库。

3.1

表单校验与 FormData

进阶

浏览器内置了一套约束校验:required、type="email"、pattern、 min / max、minlength 等属性由浏览器统一实现。 form.checkValidity() 汇总整体结果,field.validity 给出具体原因, reportValidity() 负责把原生提示气泡展示给用户。

提交拦截的标准流程是监听 submit、调用 preventDefault, 再用 FormData 收集所有带 name 的控件。 FormData 支持文件、多值与迭代,转成普通对象可以用 Object.fromEntries, 但要注意同名字段会互相覆盖,文件字段也无法直接 JSON 序列化。

自定义规则用 setCustomValidity:一旦设置非空字符串,该字段立即被视为无效; 校验通过后必须清空该字符串,否则表单会永久卡在无效状态。 表单触发 reset 时也要同步清理,避免上一次的错误信息残留。

拦截提交并统一校验

const form = document.querySelector('#signupForm');
if (!form) return;

form.addEventListener('submit', function (event) {
  event.preventDefault();            // 先拦截,避免整页刷新

  // 1. 浏览器内置约束校验
  if (!form.checkValidity()) {
    form.reportValidity();           // 展示原生气泡提示
    return;
  }

  // 2. 读取具体校验状态
  const email = form.elements.email;
  console.log('valid:', email.validity.valid);
  console.log('typeMismatch:', email.validity.typeMismatch);

  // 3. FormData 收集所有带 name 的控件
  const data = new FormData(form);
  console.log('字段数量:', [...data.keys()].length);

  // 4. 转为普通对象,便于 JSON 提交
  const payload = Object.fromEntries(data.entries());
  console.log(JSON.stringify(payload));

  // 5. 自定义校验:设置后表单即视为无效
  const password = form.elements.password;
  if (password.value.length < 8) {
    password.setCustomValidity('密码至少 8 位');
    form.reportValidity();
    password.setCustomValidity('');  // 通过后必须清空
  }
});

// reset 时清理自定义错误,避免状态残留
form.addEventListener('reset', function () {
  form.querySelectorAll('input').forEach(function (field) {
    field.setCustomValidity('');
  });
});

原生校验不是万能的。它只覆盖格式层面,跨字段依赖(确认密码、开始时间早于结束时间)仍要自己写。<form novalidate> 可以关闭浏览器默认提示,改由自定义 UI 呈现错误。

3.2

BOM:地址、历史与视口

进阶

BOM(Browser Object Model)是浏览器提供的对象集合,没有统一规范,但各浏览器实现高度一致。 location 描述当前地址,可读可写;history 支持不刷新页面地改变地址; navigator 暴露环境与能力信息;screen 与窗口尺寸属性用于布局判断。

修改地址有三种方式:location.href 会整页跳转, history.pushState 只改地址与历史记录,直接改 location.hash 只动锚点。 单页应用依靠 pushState 与 popstate 完成路由, 但 pushState 本身不会触发 popstate,只有前进后退才会。

能力探测优先于浏览器判断:检查 navigator.onLine、hardwareConcurrency、 navigator.clipboard 是否存在,比解析 userAgent 可靠得多。 尺寸方面,innerWidth 包含滚动条,document.documentElement.clientWidth 不含, 做布局计算时后者更稳。

地址、历史与尺寸

// location:当前地址的读写入口
console.log('完整地址', location.href);
console.log('路径', location.pathname);
console.log('查询串', location.search);
console.log('哈希', location.hash);

// URLSearchParams 解析查询参数,比手动切分可靠
const params = new URLSearchParams(location.search);
console.log('page =', params.get('page'));

// history:不刷新页面地改变地址
// pushState 本身不会触发 popstate,只有前进后退会
history.pushState({ step: 1 }, '', '?page=2');
window.addEventListener('popstate', function (event) {
  console.log('历史回退,状态:', event.state);
});

// navigator:做能力探测,而不是判断浏览器名称
console.log('在线状态', navigator.onLine);
console.log('语言', navigator.language);
console.log('逻辑核心数', navigator.hardwareConcurrency);

// 尺寸:innerWidth 含滚动条,clientWidth 不含
console.log('视口宽度', window.innerWidth);
console.log('文档客户区宽度', document.documentElement.clientWidth);
console.log('设备像素比', window.devicePixelRatio);

// 滚动位置与平滑回顶
console.log('当前滚动', window.scrollY);
window.scrollTo({ top: 0, behavior: 'smooth' });

用 URL 而不是字符串拼接。new URL(path, location.origin) 可以安全地拼路径、读参数、改 hash;配合 URLSearchParams 还能避免编码错误。处理带中文或特殊字符的参数时尤其明显。

3.3

本地存储:Storage、Cookie 与 IndexedDB

深入

三种存储的生命周期与容量不同:localStorage 持久保存,容量约 5MB; sessionStorage 只活在当前标签页,关闭即清; cookie 会自动随请求发送到服务器,容量约 4KB,可设置 HttpOnly 与 SameSite。

Web Storage 只存字符串,对象必须先 JSON.stringify,读取时 JSON.parse 并处理解析失败。写入可能因隐私模式或配额超限抛错,必须 try/catch。 它还是同步 API,读写大量数据会阻塞主线程,不宜存放体积过大的内容。

任何敏感信息都不应放进 localStorage:同源的任意脚本都能读取,也无法设置 HttpOnly。 大量结构化数据应考虑 IndexedDB,它支持事务、索引与二进制,容量按磁盘配额计算。 跨标签页同步可以用 storage 事件,但当前页不会收到自己触发的通知。

特性localStoragesessionStoragecookieIndexedDB
容量约 5MB约 5MB约 4KB按磁盘配额
生命周期永久,除非手动清除标签页关闭即清可设置过期时间持久,除非删除
随请求发送否否是否
JS 可读是是HttpOnly 时不可读是
API 形态同步键值同步键值字符串,需手动解析异步事务
典型用途偏好设置、进度临时草稿会话标识、埋点大量结构化数据
演示 C · localStorage 存取可交互

写入的内容会真实保存在浏览器里,刷新页面后依然存在。读取时按 JSON 解析,删除后键值立即消失。

等待操作……

序列化、容错与跨标签同步

const KEY = 'shiguang:note';

// 写入:值必须是字符串,对象先序列化
function save(text) {
  try {
    localStorage.setItem(KEY, JSON.stringify({
      text: text,
      savedAt: Date.now()
    }));
    return true;
  } catch (error) {
    // 隐私模式或超出配额(通常约 5MB)都会抛错
    console.error('保存失败:', error.name);
    return false;
  }
}

// 读取:解析失败要兜底,避免旧数据格式导致整页报错
function load() {
  const raw = localStorage.getItem(KEY);
  if (!raw) return null;
  try {
    return JSON.parse(raw);
  } catch (error) {
    localStorage.removeItem(KEY);
    return null;
  }
}

save('今天读完了 DOM 基础');
console.log(load());
localStorage.removeItem(KEY);

// sessionStorage 的 API 完全一致,生命周期只到标签页关闭
sessionStorage.setItem('draft', '临时草稿');

// 监听其它标签页的写入,当前页不会收到自己触发的通知
window.addEventListener('storage', function (event) {
  console.log('其它标签页修改了', event.key, event.newValue);
});

不要把令牌存进 Web Storage。localStorage 对同源脚本完全开放,一次 XSS 就能把登录凭证完整带走;cookie 设置 HttpOnly 后脚本无法读取,配合 Secure 与 SameSite 才是会话标识的正确存放方式。

3.4

定时器与 requestAnimationFrame

进阶

setTimeout 与 setInterval 属于宏任务,适合逻辑轮询与延迟执行; 动画则应使用 requestAnimationFrame,它在每次重绘前调用,天然与屏幕刷新节奏对齐, 页面隐藏时还会自动暂停。

流畅动画的关键是缓动与时间归一化:用 progress = elapsed / duration 计算进度,再套 easeOutCubic 之类的曲线,而不是每帧固定加几个像素。 这样在 60Hz 与 120Hz 屏幕上速度一致,也不会因为掉帧而突然跳变。

清理同样重要:重复启动前先调用 cancelAnimationFrame, 组件销毁时取消定时器,否则回调会继续访问已移除的节点,既浪费 CPU,也可能抛出空引用错误。 动画的启动与销毁应当封装在同一处,避免散落在多个函数里。

带缓动的逐帧动画

const box = document.querySelector('.card');
if (!box) return;

let rafId = 0;
let startTime = 0;
const DURATION = 800;    // 毫秒
const DISTANCE = 160;    // 像素

// easeOutCubic:起手快、收尾慢
function easeOutCubic(t) {
  return 1 - Math.pow(1 - t, 3);
}

function step(now) {
  if (!startTime) startTime = now;
  // 进度归一到 0~1,最后一帧不会越界
  const progress = Math.min((now - startTime) / DURATION, 1);
  box.style.transform = 'translateX(' + easeOutCubic(progress) * DISTANCE + 'px)';

  if (progress < 1) rafId = requestAnimationFrame(step);
}

// 重复启动前先取消,避免多个循环叠加
function start() {
  cancelAnimationFrame(rafId);
  startTime = 0;
  rafId = requestAnimationFrame(step);
}

// 组件销毁时必须清理,否则回调会继续访问已移除的节点
function dispose() {
  cancelAnimationFrame(rafId);
  rafId = 0;
}

start();
console.log('rafId =', rafId);

setTimeout(fn, 0) 的最小间隔并不为 0:嵌套超过 5 层后,浏览器会把它夹到约 4ms,后台标签页还会进一步节流。因此定时器适合“大致准时”的逻辑,绝不能用来驱动动画。

Chapter 04

界面交互实战

把前面三章的知识组装成可用的功能:可拖拽的列表、进入视口才加载的内容、随尺寸自适应的布局,以及一个能反复使用的弹窗组件。

4.1

拖拽排序

深入

拖拽排序有两种实现路线:HTML5 拖放 API 与 Pointer Events。前者只需给元素加上 draggable="true",再监听 dragstart、dragover、drop 三个事件,桌面端简单直接;后者手动跟踪坐标,能覆盖触摸屏,但代码量与边界处理都更多。

HTML5 拖放有几个必须记住的细节:dragstart 里要调用 setData, 否则部分浏览器不会真正启动拖拽;dragover 必须 preventDefault, drop 才会触发;用 getBoundingClientRect 判断指针落在目标的上半还是下半, 决定插在前面还是后面,能减少无谓的 DOM 移动。

视觉反馈依赖类名:拖拽项降低透明度,目标位置显示占位线,用户才知道会发生什么。 移动端不支持 HTML5 拖放,需要改用 Pointer Events 或成熟的手势库, 并在可拖元素上设置 touch-action: none,避免页面跟着手指一起滚动。

用 HTML5 拖放实现列表排序

const list = document.querySelector('#sortableList');
if (!list) return;

let dragging = null;

// 拖拽开始:记录源节点并写入数据
list.addEventListener('dragstart', function (event) {
  const item = event.target.closest('li');
  if (!item) return;
  dragging = item;
  item.classList.add('is-dragging');
  event.dataTransfer.setData('text/plain', item.dataset.id);
  event.dataTransfer.effectAllowed = 'move';
});

// 拖拽经过:必须阻止默认行为,drop 才会触发
list.addEventListener('dragover', function (event) {
  event.preventDefault();
  const target = event.target.closest('li');
  if (!target || target === dragging) return;

  // 用垂直中点判断插在前面还是后面
  const rect = target.getBoundingClientRect();
  const after = event.clientY > rect.top + rect.height / 2;
  list.insertBefore(dragging, after ? target.nextSibling : target);
});

// 拖拽结束:清理视觉状态
list.addEventListener('dragend', function () {
  if (dragging) dragging.classList.remove('is-dragging');
  dragging = null;
});

// 放置完成:读取最终的顺序
list.addEventListener('drop', function (event) {
  event.preventDefault();
  const order = [...list.children].map(function (li) { return li.dataset.id; });
  console.log('新的顺序:', order.join(' → '));
});

触摸屏没有 dragstart。iOS 与多数移动浏览器不会把手指拖动映射为 HTML5 拖放事件。需要移动端可用,就必须用 Pointer Events 自行实现,或直接采用支持触摸的排序库,并在开始拖拽时阻止页面滚动。

4.2

IntersectionObserver 与懒加载

深入

IntersectionObserver 异步观察元素与视口的交叉状态,回调在渲染后的空闲时机批量执行, 不像 scroll 监听那样每帧同步计算。它把“元素是否可见”这件昂贵的事交给浏览器内部完成。

懒加载图片的标准做法是:用 data-src 保存真实地址,进入视口后赋给 src, 并立即 unobserve。参数上,rootMargin 可以提前加载, threshold 控制触发比例;入场动画同理,触发一次后就取消观察,避免反复执行。

它也有边界:无法观察 display: none 的元素,不适合做精确的滚动进度, 需要逐帧数据时仍要回到 scroll 配合 rAF。 回调里不要做同步重活,否则会推迟渲染,抵消掉它本来带来的性能收益。

懒加载与入场动画

const images = document.querySelectorAll('img[data-src]');

// 懒加载:进入视口后才把 data-src 写入 src
const io = new IntersectionObserver(function (entries, observer) {
  entries.forEach(function (entry) {
    if (!entry.isIntersecting) return;
    const img = entry.target;
    img.src = img.dataset.src;
    img.removeAttribute('data-src');
    observer.unobserve(img);      // 加载后取消观察,避免重复触发
  });
}, {
  root: null,                     // null 表示视口
  rootMargin: '200px 0px',        // 提前 200px 开始加载
  threshold: 0.01                 // 可见 1% 即视为进入
});

images.forEach(function (img) { io.observe(img); });

// 入场动画:一次性触发,触发后立即断开
const revealObserver = new IntersectionObserver(function (entries) {
  entries.forEach(function (entry) {
    if (!entry.isIntersecting) return;
    entry.target.classList.add('is-visible');
    revealObserver.unobserve(entry.target);
  });
}, { threshold: 0.15 });

document.querySelectorAll('.reveal').forEach(function (item) {
  revealObserver.observe(item);
});

优雅降级。老浏览器可能不支持观察器。初始化前判断 typeof IntersectionObserver,不支持时直接把 data-src 全部赋给 src,让内容先完整呈现,再谈动画与性能。

4.3

ResizeObserver 与自适应布局

深入

ResizeObserver 监听元素自身的尺寸变化,比 window.resize 精确得多:它不依赖视口,能感知 Flex、Grid 引起的局部变化,回调里提供 contentRect 与 borderBoxSize,方便直接做布局决策。

最大的陷阱是循环触发:在回调里修改被观察元素自身的尺寸,会再次触发回调, 浏览器检测到后抛出 ResizeObserver loop 错误并跳过本帧。 规避方式有三种:改子元素而不是自身;把布局写入放进 requestAnimationFrame; 用标志位去重。

组件销毁时务必 disconnect,否则观察器会继续持有已移除节点的引用。 若只关心首次尺寸,可以在回调里立即断开;若需要在容器切换时重新观察, 记得保留观察器实例,而不是每次新建。

监听尺寸并避免循环

const target = document.querySelector('.content');
if (!target) return;

// 回调可能在同一帧收到多条记录
const ro = new ResizeObserver(function (entries) {
  for (const entry of entries) {
    const rect = entry.contentRect;
    console.log('内容尺寸', Math.round(rect.width), Math.round(rect.height));

    // 只在尺寸真正变化时写样式,减少无谓回流
    if (rect.width < 640) {
      target.classList.add('is-narrow');
    } else {
      target.classList.remove('is-narrow');
    }
  }
});

ro.observe(target);
// box 选项可以改为监听 border-box
ro.observe(document.querySelector('.page-hero'), { box: 'border-box' });

// 不要在回调里修改被观察元素自身的尺寸,否则会形成
// ResizeObserver loop:浏览器报错并跳过本帧

// 组件销毁时断开,避免持有已移除节点的引用
window.addEventListener('pagehide', function () {
  ro.disconnect();
});

// 只关心首次尺寸时,回调里立即断开
const once = new ResizeObserver(function (entries, observer) {
  console.log('首次宽度', entries[0].contentRect.width);
  observer.disconnect();
});
once.observe(target);

ResizeObserver 回调运行在渲染前,并在同一帧内批量投递。若在其中触发同步布局读取,可能造成布局抖动;把写操作放进 requestAnimationFrame,读操作集中在回调开头,能有效避免反复回流。

4.4

可复用的 Modal 组件

实战

可复用组件要同时处理结构、样式、行为与可访问性。Modal 的骨架通常是遮罩层加对话框: 对话框设置 role="dialog"、aria-modal="true" 与 aria-label, 标题与正文由参数注入,按钮统一走 data-close 标记。

焦点管理是 Modal 的核心。打开时记录当前焦点并把焦点移入对话框,关闭时归还; Tab 键应在对话框内循环,避免焦点跑到背景页面。Esc 关闭、点击遮罩关闭, 同时点击对话框内部不应关闭,这些是用户的基本预期。

销毁要彻底:移除节点、解绑 keydown、恢复焦点、解除 body 的滚动锁定。 把这些动作收进同一个 close 函数,组件才不会在页面里留下看不见的监听器。 能用原生 <dialog> 时也可以优先考虑,它自带模态与 Esc 行为。

结构、焦点与关闭逻辑

function createModal(options) {
  const settings = Object.assign({ title: '提示', content: '' }, options);

  // 1. 结构:遮罩层包裹对话框,并补齐无障碍属性
  const mask = document.createElement('div');
  mask.className = 'modal-mask';
  const dialog = document.createElement('div');
  dialog.className = 'modal';
  dialog.setAttribute('role', 'dialog');
  dialog.setAttribute('aria-modal', 'true');
  dialog.setAttribute('aria-label', settings.title);
  dialog.innerHTML = '<h3 class="modal-title"></h3>' +
    '<p class="modal-body"></p>' +
    '<button type="button" data-close>关闭</button>';
  dialog.querySelector('.modal-title').textContent = settings.title;
  dialog.querySelector('.modal-body').textContent = settings.content;
  mask.append(dialog);

  // 2. 记录打开前的焦点,关闭后归还
  const previousFocus = document.activeElement;

  function close() {
    document.removeEventListener('keydown', onKeydown);
    mask.remove();
    if (previousFocus && typeof previousFocus.focus === 'function') {
      previousFocus.focus();
    }
  }

  // 3. Esc 关闭,点击遮罩或关闭按钮也关闭
  function onKeydown(event) {
    if (event.key === 'Escape') close();
  }
  document.addEventListener('keydown', onKeydown);
  mask.addEventListener('click', function (event) {
    if (event.target === mask || event.target.closest('[data-close]')) close();
  });

  // 4. 挂载后把焦点移入对话框
  document.body.append(mask);
  dialog.querySelector('[data-close]').focus();

  return { close: close, element: dialog };
}
createModal({ title: '确认', content: '可复用的弹层内容。' });

原生 dialog。<dialog> 的 showModal() 自带遮罩、Esc 关闭与焦点限制,配合 ::backdrop 即可定制背景。若还要支持旧浏览器或复杂动效,再回到手动实现。