跳到正文
零到全栈 · 卷 4 · 从页面到应用

为什么需要框架

本合集目录
本章目录

单册说明:本文件是卷 4 的第 1 章,可独立阅读。前置:卷 2 第 5 章(DOM 与事件)、卷 3 第 4 章(ESM 模块)。本章一行 React 都不写,只用一段 30 行的原生 JS 让你亲手摸到手写 DOM 的三笔债,再决定要不要上框架。

项 内容
所属卷 卷 4 · React 与 Next.js(第 1 / 8 章)
前置章节 3.4 从脚本到模块、3.6 Vite 开发与构建;2.5 DOM 与事件
本章产出 一份 30 行的手写版本 + 一张"要不要上框架"的判断表
对应代码 vanilla-notes.html(4.1.3 完整给出,单文件,浏览器直接打开)
配图 无(后续统一制图)
读完的判定 能指着自己的代码说出"这份状态被存了几份、分别在哪"

4.1.1 一句话结论:手写 DOM 的贵,不在写,而在"同步"

先看一个真实工单。功能是这样的:摘录列表上方有标签筛选,下方有"共 N 条"的计数,列表空了要显示一句提示。上线第二天用户反馈:

我点了「css」标签,下面只剩两条,上面还写着"共 8 条"。而且搜索框里还是我上一条的标题。

这不是他不会写 JS。打开代码你会发现,他真的改了列表——三处该改的地方,他改了两处。

手写 DOM 的成本不在第一次渲染,而在每一次"数据变了之后"。 数据变一次,你要记得同步:列表节点、计数文字、空态提示、按钮高亮、输入框的值、页面的 title。漏一个,就是一个 bug;而这个 bug 不会报错,只会让界面说谎。

框架解决的正是这件事。它不是让你少打字,是让你只改一处。

4.1.2 原理与方法

三笔债:状态、复用、路由

把手写方案的问题归成三类,后面每一章都在还这三笔债。

债 具体形态 什么时候开始疼
状态散落 数据在数组里、显示在 DOM 里、临时值在 input.value 里,三份"真相" 任何一次改动都要记得同步另外两处
复用靠复制 复制 HTML 片段、复制 querySelector、复制更新逻辑 第二份拷贝出现的那一刻
路由自己拼 监听 hashchange,用 if/else 决定显示哪一块 出现第三个页面时

这张表值得抄在纸上。卷 4 的八章,4.2 解决复用,4.3 解决状态,4.5 解决路由,4.6 之后解决"页面在服务器上怎么组织"。

债一:DOM 是另一份状态存储

新手会以为"数据在 JS 里,DOM 只是显示"。实际上 DOM 自己也在存状态,而且是更权威的那一份:

状态 存在哪 谁在改它
当前筛选的标签 一个 let activeTag 变量 你的点击回调
输入框里的文字 input.value(DOM 节点上) 用户敲键盘,不经过你的变量
哪一项展开着 某个 li 的 class 你的回调
列表有几条 notes.length 你的回调
页面上写着的"共 N 条" 一个文本节点 你的回调,而且经常被忘

看第二行:用户打字时,DOM 的值变了,你的变量没变。反过来,你用代码把变量改了,DOM 也不会自动变。两个方向都要你手动搬。

于是"一份数据"变成"两份数据 + 一个同步协议",而这个协议写在你的脑子里,不在代码里。人一忙,协议就漏。

债二:复用靠复制

列表里每一项要有标题、正文、标签、删除按钮。你写好一份,第二份怎么办?复制。

复制的代价不是多几十行,而是以后每次改需求,你要改 N 份。给卡片加一个"来源链接",你改了第一份,忘了第三份;三个月后有人问"为什么有的卡片没有链接",你打开代码发现有三段几乎一样但不一样的 HTML 字符串。

用函数封装能缓解,但封装的边界会漂移:一开始 renderNote(note) 只返回字符串,后来要加删除按钮 → 需要传回调;再加展开 → 需要局部状态。函数参数从 1 个长到 5 个,最后你写出了一个粗糙的、没有名字的框架。

债三:路由自己拼

三个页面:首页、列表、详情。手写通常是:

window.addEventListener('hashchange', () => {
  const hash = location.hash.slice(1) || '/';
  if (hash === '/') showHome();
  else if (hash === '/notes') showList();
  else if (hash.startsWith('/notes/')) showDetail(hash.split('/')[2]);
  else show404();
});

能跑。但它有三个隐藏问题:

  1. 路由表是一条 if 链,加页面要改这段,改错了没有编译期检查;
  2. 每个 showXxx 都要自己负责"清理上一个页面"(定时器、监听器);
  3. 用 hash 时服务端永远只收到 /,分享出去的链接和你看到的不是同一个东西。

声明式与命令式:同一需求的两种写法

需求:显示筛选后的摘录,同时更新计数和空态。

命令式(告诉浏览器"怎么做",一步一步):

function renderList(notes) {
  const list = document.querySelector('#note-list');
  list.innerHTML = '';
  for (const note of notes) {
    const li = document.createElement('li');
    li.textContent = note.title;
    list.appendChild(li);
  }
  document.querySelector('#count').textContent = `共 ${notes.length} 条`;
  document.querySelector('#empty').hidden = notes.length > 0;
}

声明式(告诉框架"应该是什么样",怎么改它自己算):

function NoteList({ notes }) {
  if (notes.length === 0) return <p>还没有摘录</p>;
  return (
    <section>
      <p>共 {notes.length} 条</p>
      <ul>{notes.map((n) => <li key={n.id}>{n.title}</li>)}</ul>
    </section>
  );
}

差别在哪?命令式里,"计数"是第二件要做的事;声明式里,"计数"只是 notes.length 的第二次使用。前者需要你记得做,后者不需要。

关注点 命令式 声明式
你描述的是 步骤 结果
新增一个要同步的元素 加一行代码 + 记得调用 加一个表达式,无需同步
出错的形态 漏同步,界面不一致 表达式算错,通常是逻辑错
复用 抽函数,参数越来越多 抽组件,输入输出清晰
调试 打断点看执行顺序 看"这一轮 state 是什么,UI 该是什么"

一个准确的类比:命令式是手动挡,你要管什么时候换挡;声明式是自动挡,你只管方向和速度。自动挡不是"更快",是"你不用管"。

虚拟 DOM 到底解决什么

这一节要拆掉一个流行误解:虚拟 DOM 不是"更快"。

真实情况:一个 20 条的列表,只改一个 class,手写 el.classList.add('active') 比"生成虚拟树 → diff → patch"快得多。虚拟 DOM 多了一层内存对象,首次渲染还要多做一次转换。

它买的是另外三样东西:

收益 说明
你不用决定更新什么 你重算整棵 UI,库负责找出最小改动。漏同步的问题从"人记得不记得"变成"库算得对不对"
更新是批量的、可预测的 一次事件里改五个状态,只渲染一次,不会中间态闪屏
UI 变成纯函数 UI = f(state)。同一个 state 一定得到同一个界面,这让测试和排查有了着力点

代价也要说清楚:多一层运行时开销、初次渲染略慢、学习成本(依赖数组、key、闭包旧值——后面三章全是这些坑)。

所以判断标准不是"框架快不快",而是**"你的界面里有没有一份状态,需要在多个地方保持一致"**。

什么时候不该上框架

情况 建议 理由
一个纯展示的介绍页 不上 没有状态,没有同步问题
交互点少于 3 个(比如只有一个"展开全文") 不上 引入构建链的收益为负
必须在禁用 JS 时可用 不上(或只做渐进增强) 框架的产物默认需要 JS
两周内要交付、团队没人写过 先不上 学习成本会吃掉交付时间
列表要频繁增删改、多个区域联动 上 这正是它的主场
要做多页面、要 SEO、要首屏快 上,并且用服务端渲染 见 4.6、4.7

一句话判断:"我改一个值,需要动几个地方?" 答案是 1,就别上;答案是 3 以上,就上。

4.1.3 动手:30 行,改一处漏两处

新建一个文件 vanilla-notes.html,双击用浏览器打开。不用装任何东西。

<!DOCTYPE html>
<html lang="zh-CN">
<head>
  <meta charset="utf-8">
  <title>读到 · 手写版</title>
  <style>
    body { font-family: system-ui, sans-serif; max-width: 640px; margin: 40px auto; line-height: 1.6; }
    li { padding: 8px 0; border-bottom: 1px solid #eee; }
    button { margin-right: 6px; }
  </style>
</head>
<body>
  <h1>读到</h1>
  <p id="count"></p>
  <div id="filters"></div>
  <ul id="list"></ul>
  <p id="empty" hidden>没有匹配的摘录</p>

  <script>
    const notes = [
      { id: 1, title: '闭包是函数和它的词法环境', tags: ['js'] },
      { id: 2, title: '盒模型把内容、内边距、边框、外边距分开算', tags: ['css'] },
      { id: 3, title: 'useEffect 的清理函数在下次执行前调用', tags: ['js', 'react'] },
    ];
    let activeTag = 'all';

    const listEl = document.querySelector('#list');
    const countEl = document.querySelector('#count');
    const emptyEl = document.querySelector('#empty');
    const filtersEl = document.querySelector('#filters');

    function render() {
      const visible = activeTag === 'all'
        ? notes
        : notes.filter((n) => n.tags.includes(activeTag));

      listEl.innerHTML = '';
      for (const note of visible) {
        const li = document.createElement('li');
        li.textContent = note.title;
        listEl.appendChild(li);
      }
      countEl.textContent = `共 ${visible.length} 条`;
      emptyEl.hidden = visible.length > 0;
    }

    const tags = ['all', ...new Set(notes.flatMap((n) => n.tags))];
    for (const tag of tags) {
      const btn = document.createElement('button');
      btn.textContent = tag;
      btn.addEventListener('click', () => { activeTag = tag; render(); });
      filtersEl.appendChild(btn);
    }

    render();
  </script>
</body>
</html>

预期效果:页面上出现 共 3 条、四个按钮(all / js / css / react)、三条摘录。点 css,列表只剩一条,计数变成 共 1 条。

现在做三个实验,每个只要改一行。

实验一:删掉同步。 把 countEl.textContent = ... 这一行注释掉,刷新,点 css。列表正确变成一条,计数还停在 共 3 条。这就是开头那个工单。你并没有写错逻辑,你只是少写了一行——而代码不会提醒你。

实验二:加一处高亮。 需求是"当前选中的标签要突出显示"。你会发现光有 activeTag 不够,还得能拿到所有按钮的引用,于是多一个 buttons 数组,在 render() 里再循环一遍改 className。30 行变 38 行,同步点从 3 个变 4 个。

实验三:加一个编辑框。 给每条 li 里塞一个 <input value={title}>。然后点删除第一条,你会看到:第二条的输入框内容"跳"到了第一条的位置,或者你正在输入的光标突然跑到别的行。原因是你在 innerHTML = '' 之后重建了整个列表,浏览器里所有输入状态都被扔掉了。这个问题在 4.2 会以 key 的形式正式解决。

三个实验做完,你应该能感到那三笔债不是理论:每一笔都对应你亲手删掉或忘记的一行代码。

4.1.4 三个坑

坑一:用 innerHTML 拼用户输入

症状:某条摘录的正文里存了 <img src=x onerror="alert(1)">,列表一打开就弹窗;或者整页布局突然塌掉,标签全乱。

成因:innerHTML 会把字符串当 HTML 解析。你以为是"显示文字",浏览器以为是"执行标记"。这条路径就是最常见的 XSS(跨站脚本)入口。

修法:纯文本一律用 textContent。确实要渲染富文本时,先用白名单清洗(允许哪些标签、哪些属性),再插入;清洗库的选择与配置放在卷 8 的安全章。现在的原则只有一句:用户输入永远不当代码。

// 错的
li.innerHTML = `<span>${note.title}</span>`;

// 对的
const span = document.createElement('span');
span.textContent = note.title;
li.appendChild(span);

坑二:循环里绑事件,又用索引删数据

症状:列表三条,点第二条的"删除",消失的却是第三条;刷新后又正常,一点又错。

成因:回调闭包里捕获的是渲染那一刻的 index。删除后列表重排,index 和数据的对应关系变了,但闭包里存的还是旧数字。如果中间还做过筛选,错位会更随机。

修法:让事件携带身份,而不是位置。

// 错的:闭包捕获 i,重排后失效
items.forEach((item, i) => {
  btn.addEventListener('click', () => removeAt(i));
});

// 对的:把 id 写进 DOM,用事件委托读回来
li.dataset.id = note.id;
listEl.addEventListener('click', (e) => {
  const id = e.target.closest('[data-id]')?.dataset.id;
  if (id) removeById(id);
});

事件委托还有一个附带好处:新增的节点不用再绑一次。

坑三:整表重建,输入状态全丢

症状:搜索框里每敲一个字,光标就跳到末尾;用中文输入法时,拼音还没选完就被打断;列表里的输入框输到一半,内容突然清空。

成因:每次输入都触发一次 innerHTML = '' 加全量重建。DOM 节点被销毁,浏览器保存的焦点、光标位置、输入法组合状态全部丢失。

修法:只更新变化的节点,不要重建整棵树。手写要做到这一点,需要给每个节点一个稳定标识、做 diff——这已经是在实现一个框架了。所以这个坑的正确修法其实是换工具:4.2 的 key 就是这件事的标准化答案,React 会根据 key 复用节点,只改变化的部分。

本章验收

  • 能说出三笔债的名字,并各举一个自己遇到过的现象
  • 能默写"改一个值要同步几个地方"的判断,并给出自己的答案
  • 跑通 vanilla-notes.html,完成三个实验,看到计数不同步、高亮要多写一段、输入状态丢失
  • 能解释虚拟 DOM 不是"更快",那它买的是什么
  • 能说出两种"不该上框架"的情况

自测

Q1:为什么说"数据在 JS 里,DOM 只是显示"这句话是错的?

看答案 因为 DOM 自己保存着大量状态:输入框的 value、复选框的 checked、元素的 class、滚动位置、焦点。用户直接操作这些,不经过你的变量;你用代码改变量,DOM 也不会自动跟着变。所以真实情况是"两份状态 + 一个靠人维护的同步协议"。框架的价值就是把这份协议变成自动执行的。

Q2:虚拟 DOM 在什么情况下反而比手写 DOM 慢?那为什么还用它?

看答案 改动极小、结构极简单时(比如只切换一个 class),手写直接操作节点是最快的,虚拟 DOM 要多做一次树构建和 diff。它换来的是:你不用判断"该更新哪一块",界面由 state 推导,不会出现漏同步。选它的理由是正确性和可维护性,不是性能。

Q3:一个页面只有一个"展开全文"按钮,要不要上 React?给出你的判断依据。

看答案 不需要。判断依据是"有没有一份状态需要在多个地方保持一致"。这里只有一处 UI 依赖一个布尔值,手写三行 `classList.toggle` 就够,引入构建链、依赖、学习成本都是负收益。等出现列表增删、多区域联动、需要路由时再迁移,迁移成本也不会比现在高。

下一步

债认清了,开始还第一笔:把界面拆成组件,让"复用"不再靠复制。下一章你会写出 NoteCard、NoteList、TagFilter,并搞清 key 到底在修哪个 bug。

→ 卷4-02-组件props与JSX.md