跳到正文
零到全栈 · 卷 9 · 卷 9

附录E 术语表

本合集目录
本章目录

本附录收录全书出现过的 120 个术语,按主题分成 8 组。每条四列:一句话解释、常见误用、见哪一卷。 用法:卡住时查,不要从头背。查不到就搜缩写表。


使用说明

一、这张表是查的,不是背的

术语表最容易被当成"考前背诵清单":从第一行读到第一百二十行,合上文档记住零个。这本书里的术语不是考点,是排查时的坐标。你在日志里看到 502,需要的不是"网关错误"这四个字的定义,而是"谁报的、下一步该查哪一段";你在控制台看到 blocked by CORS policy,需要的不是 CORS 的全称,而是"请求其实早就到服务器了"这个反直觉的事实。所以这张表按"你会在哪儿撞到它"编排,不按拼音或字母排序。

查法有三种,按你手头的信息选:

  • 知道中文名,按组翻。 八组的顺序和全书的能力带一致:网络 → 命令行 → 语言 → 工程 → 框架 → 接口 → 数据 → 上线。你卡在哪一层,就翻哪一组;不确定卡在哪一层,先翻第 ① 组,因为大部分"打不开"都落在网络层。
  • 只记得一个词,用全文搜索。 Ctrl+F 或 Cmd+F,搜"预检"到 ⑥,搜"水合"到 ⑤,搜"锁"会命中事务与迁移那一带的几条。
  • 只记得缩写,翻最后的速查表。 那里给全称和一句中文,确认是你要找的东西,再回到正文组里看细节。

"见哪一卷"给的是第一次系统讲它的地方,不是唯一出现的地方。比如 Cookie 在卷 5 联调时已经露过面,但真正讲清 HttpOnly、SameSite、Secure 的是卷 6;表里标卷 6,是因为你读完那一章才算真的会用。卷 0 只标给那些"地图级"的概念——端口、TCP、TLS,它们在第 3 章的全景图里第一次有了位置,后面每一卷都在复用那张图。

二、为什么每条都要写"常见误用"

因为术语的难点从来不在定义,在用错时的样子。

定义是可以背的:"CORS 是跨源资源共享。"背完这句话,你遇到 CORS 报错仍然会去改前端,而真正该改的是后端的响应头。反过来,如果你记住的是"'请求被拦截了'这个读法是错的——请求早就执行完了,只是响应被浏览器扣下",你第一次遇到就能往对的方向走。一个术语的价值,等于它能帮你排除掉多少错误方向。

三个例子,说明"误用"和"定义"差多远:

  • TTL。 定义是"记录的缓存时间"。误用是"改完 DNS 立刻刷新页面,看到旧 IP 就以为没保存"。知道定义救不了你,知道"1 小时 TTL 意味着最坏要等 1 小时"才能让你停止反复改记录。
  • 幂等。 定义是"重复执行结果一致"。误用是"给创建接口加了重试,用户双击就多出两条摘录"。定义背得再熟,不在写重试逻辑时想起它,一样出事。
  • hydration。 定义是"客户端接管服务端 HTML"。误用是"首屏用了 Math.random() 或 Date.now(),服务端和客户端算出两个值,控制台报不一致"。这个错只在真跑起来时出现,看书时永远遇不到。

所以每条"常见误用"都写成一句真实会发生的操作,不是把定义反过来说一遍。它们的共同结构是:做法看起来合理,当场也有反馈,代价在后面。绝对路径在你自己电脑上永远正确,换台机器就全线报错;chmod 777 能让 403 立刻消失,同时把"读不到"升级成"谁都能改";健康检查返回 200 让人放心,可它没查数据库,库挂了它还是 200。这类错误的可怕之处不在难,而在它不会当场拦住你。

三、缩写怎么读

缩写的读法没有全国统一标准,但有三类习惯,知道分类就不会现场卡壳:

  • 逐字母读。 API、CSS、DNS、HTML、HTTP、URL、JWT、SQL(SQL 也有人读"sequel",两种都通行)。
  • 拼成一个词读。 CORS 读"科斯",REST 读"瑞斯特",SPA 读"斯帕",WAL 读"wall",TTFB 一般逐字母。
  • 混合。 HTTPS 读"H-T-T-P-S"(五个字母全读),URI 读"U-R-I",CI/CD 读"C-I 斜杠 C-D"。

讨论时不必纠结"标准读法"。团队里读法一致,比读得"正确"更有用;口头说不清就直接念全称,没有人会因此觉得你不专业。真正会造成误解的是把缩写当成一个词去理解:API 不是一个网址,REST 不是一种协议,SSR 也不是"一台服务器"。缩写只是省字的写法,展开之后的每个词才是信息。

四、三条使用约定

  1. 一条术语只在一个组里出现一次。 跨组重名的加限定词区分,例如"环境变量"(第 ② 组,进程里的键值)与"环境变量注入"(第 ④ 组,构建时写进产物);"回滚"在第 ⑦ 组指事务撤销,在第 ⑧ 组指版本切回。
  2. "一句话解释"控制在 40 字内。 目的是让你扫一眼就知道该不该往下看,真正的展开在正文那一章。40 字讲不清的,说明你需要的是那一章,不是这一行。
  3. 表里的判断都能在书里找到对应的失败现场。 如果某条你只记住了结论、想不起场景,回到标注的那一卷,直接翻那章的"三个坑"——那里的症状描述比这里的定义有用。

① 基础与网络(16 条)

这一组讲"你的请求离开电脑之后"发生的事。共同点是:你只能配置,不能修改;坏了也不是你的代码坏了。把这 16 个词认全,卷 0 第 3 章那张六段图才有细节可看,卷 7 的排障也才有下手的地方。

术语 一句话解释 常见误用 见哪一卷
IP 网络上一台机器的数字门牌,如 192.168.1.7 把 127.0.0.1 当成"我在公网上的地址",发给别人却打不开 卷 1
端口 同一台机器上区分不同服务的编号,HTTP 默认 80 以为换个冷门端口就能藏住服务,扫描一遍照样被发现 卷 1
DNS 把域名翻译成 IP 的分布式电话簿 改完记录立刻刷新验证,看到旧 IP 就反复改,其实 TTL 还没过 卷 1
TTL 一条 DNS 记录能在各级缓存里活多少秒 上线切换前把 TTL 设成 86400,切错了要等一天才能改回来 卷 7
域名 人记得住的名字,最终指向某个 IP 或另一个名字 以为买了域名就等于有了网站,其实还要解析、还要服务器 卷 7
A 记录 把域名直接指向一个 IPv4 地址的记录 服务器换了 IP 只改 Nginx,忘了改 A 记录,域名还指着旧机器 卷 7
CNAME 把域名指向另一个域名,由后者继续解析 在根域(@)上挂 CNAME,和邮箱的 MX 记录打架,邮件收不到 卷 7
TCP 先握手、按序到达、丢了会重发的传输层协议 把"连接超时"当成 TLS 或代码问题,其实连门都没敲开 卷 0
TLS 在 TCP 之上做加密和身份验证的一层 以为上了 HTTPS 网站就安全,注入和越权照样发生 卷 7
HTTP 浏览器与服务器之间"请求—响应"的文本约定 把 HTTP 当成加密传输,抓包一看全是明文 卷 5
HTTPS 把 HTTP 放进 TLS 里传,默认走 443 证书装好了就放心,页面里的 http 图片仍被当成混合内容拦掉 卷 7
请求 客户端发出的一条"我要什么"的报文 把"请求已发出"当成"请求已成功",其实响应可能被浏览器扣下 卷 5
响应 服务器回给客户端的状态码、响应头和响应体 只看 body 不看状态码,200 里包着一个 error 对象也当成成功 卷 5
同源 协议、域名、端口三者全同才算同一个源 把 localhost 和 127.0.0.1 当成同源,登录后 Cookie 死活带不上 卷 5
跨源 三者有任一不同,读响应要服务器点头 以为跨源请求"发不出去",其实常常是发出去了、读不到 卷 5
CDN 把静态文件复制到离用户更近的节点上 给带 Cookie 的接口响应配 CDN 缓存,把 A 用户的数据发给 B 卷 7

这一组最容易混的三对

同源 vs 跨源。 同源判的是协议、域名、端口三项是否全等,不是"看起来像同一个网站"。https://dudao.example.com 与 https://api.dudao.example.com 是跨源,http://localhost:3000 与 http://127.0.0.1:3000 也是跨源——浏览器比的是字符串,不做"都是本机"的推断。跨源也不等于请求发不出去,它管的是"读不读得到响应"。

A 记录 vs CNAME。 A 记录直接把域名钉到一个 IP,CNAME 把域名指向另一个域名、让别人再去解析。前者适合"这个 IP 我说了算",后者适合"地址由服务商管、随时可能变"。根域上挂 CNAME 会和 MX 记录冲突,这是配企业邮箱时最常见的翻车。

HTTP vs HTTPS。 HTTP 是明文约定,HTTPS 是把同一套报文放进 TLS 里传。差别不只是地址栏有没有小锁:HTTPS 同时解决"别人能不能看"和"对面是不是真的它"。但 HTTPS 不检查内容是否合法,注入、越权、弱密码在 HTTPS 站点上照样发生。


② 命令行与系统(14 条)

命令行的词有一个共同点:它们描述的是"你此刻的处境",不是"文件本身"。同一个文件,从不同目录看,相对路径就不一样;同一条命令,PATH 不同,找到的可能是另一个版本。这一组的所有事故,几乎都能归结为"我以为它指的是那个,其实指的是这个"。

术语 一句话解释 常见误用 见哪一卷
终端 让你用文字命令操作电脑的窗口程序 把终端和 shell 当成一回事,换了终端就以为换了 shell 卷 1
shell 真正读懂你敲的命令、再交给系统的程序 把 zsh 的写法粘进 PowerShell,报错看起来像"命令不存在" 卷 1
PATH 系统找可执行文件时按顺序搜索的目录清单 装完命令能用,重开终端就找不到,因为只临时改了 PATH 卷 1
环境变量 存在进程里、给程序读的一堆键值配置 把密钥写进 .env 又提交,以为删掉文件历史里就干净了 卷 7
绝对路径 从根目录写起的完整路径,在哪执行都指向同一处 把 /Users/你的名字 写进脚本,换台机器全线报错 卷 1
相对路径 相对于"你此刻所在目录"的路径 以为它相对于脚本文件,其实相对于你执行命令时所在的目录 卷 1
家目录 登录后默认落脚的个人目录,Linux 上是 /home/你 把网站文件放家目录又改成 777,指望 Nginx 能安全地读 卷 1
权限位 用 rwx 三组九位描述谁可读、可写、可执行 一遇 403 就 chmod 777,把"读不到"升级成"谁都能改" 卷 1
属主 文件归属的用户和用户组,权限按它来套 用 root 跑应用,日志和库文件全归 root,换用户启动就写不进去 卷 7
进程 一个正在运行的程序实例,有自己的内存和 PID 改完代码没重启进程,反复刷新页面,以为改动没生效 卷 7
端口监听 某个进程在某个地址和端口上等连接进来 服务只听 127.0.0.1,本机测试全通、外面一律超时 卷 0
标准输入输出 每个进程自带的三个通道:进来、出去、报错 把日志打到标准输出又用 > 接走,程序一重启日志就空 卷 1
管道 把前一个命令的输出直接喂给下一个命令 管道里塞一个要交互的命令,整条命令卡在那儿等输入 卷 1
重定向 把命令的输入或输出改到文件、设备或别处 用 > 记日志,每次重启都把上一次的现场清空,该用 >> 卷 1

这一组最容易混的三对

终端 vs shell。 终端是窗口,shell 是窗口里那个读懂命令的程序。换终端(iTerm、Windows Terminal)不会换 shell;换 shell(bash、zsh、PowerShell)语法就变了。教程里最常见的事故,是把 zsh 的写法粘进 PowerShell,报错看起来像"命令不存在",其实是语法不认。

绝对路径 vs 相对路径。 绝对路径从根写起,在哪执行都一样;相对路径从"你此刻所在目录"算起,和脚本放在哪无关。脚本里写 ./data.db,从别的目录调用就会指向别处——这就是"手动跑正常、定时任务失败"的经典成因。

管道 vs 重定向。 管道把前一个命令的输出交给后一个命令当输入,数据还在流动;重定向把输出接到文件或设备,数据落了地。> 是覆盖,>> 是追加。用 > 记日志,每次重启都会清空现场,出事时最想看的恰好是上一次。


③ 前端语言(18 条)

这一组的词几乎都围绕两件事:代码在哪个范围里被看见,以及代码按什么顺序跑。作用域、闭包、提升、this 讲"谁能看见谁";同步、异步、事件循环、微任务讲"谁先跑"。这两类问题在报错里长得完全不一样,根因却常常是同一个:你对"此刻这个值是什么"的判断错了。

术语 一句话解释 常见误用 见哪一卷
DOM 浏览器把 HTML 解析成的一棵可编程节点树 以为改 DOM 就是改 HTML 文件,刷新后改动全没了 卷 2
事件 用户或浏览器的某个动作,被包成对象交给回调 在元素还没渲染时就绑定,报 Cannot read properties of null 卷 2
冒泡 事件从最内层元素逐级向外层传递 以为 stopPropagation 能挡住同元素上的其他监听器,其实只挡外层 卷 2
委托 把监听器挂在父元素上,靠冒泡统一处理子元素 给每个列表项单独绑事件,新增的那一项点了没反应 卷 2
闭包 函数连同它定义时所在的作用域一起被保留 以为闭包要主动开启,其实写了嵌套函数就已经有了 卷 2
作用域 一个变量在代码里能被看见的范围 函数里漏写声明,以为它是局部变量,其实挂到了全局 卷 2
提升 声明在代码执行前先被登记到作用域顶部 以为 let 不提升,在声明前访问得到 undefined 而不是报错 卷 2
引用类型 变量里存的是地址,多个名字可能指向同一块数据 用 slice 复制数组就以为隔离了,里面的对象还是共享的 卷 2
原型 对象找不到属性时,顺着一条链去问的上一级对象 给 Array.prototype 加方法,污染所有数组和第三方库 卷 2
this 函数执行时由"谁调用它"决定的当前对象 把对象方法存成变量再调用,this 变成 undefined 卷 2
同步 代码一行一行执行,上一行没完下一行等着 以为同步代码能"等一下"网络返回,结果只能靠回调 卷 2
异步 先交出去、稍后再回来处理的执行方式 以为 setTimeout(fn, 0) 是立刻执行,其实排在同步代码之后 卷 2
事件循环 不断把队列里的回调搬进主线程执行的机制 以为谁先注册谁先跑,忽略了微任务会在下一轮之前清空 卷 2
微任务 同步代码跑完后、下一轮渲染前清空的高优先队列 在微任务里无限 then,页面直接卡死,连渲染机会都没有 卷 2
Promise 表示"将来会有结果"的对象,有三个状态 忘了 return 或 await,错误被吞进一个没人处理的 Promise 卷 2
async/await 用同步写法组织异步流程的语法糖 在 forEach 回调里 await,以为会一个个跑完,其实并发发出 卷 2
模块 一个文件里封装好、只导出需要部分的代码单元 用 file:// 直接打开带 import 的页面,被跨源规则拦住 卷 3
ESM 浏览器和 Node 都认的标准模块语法 import/export 在 Node 里写 import 却没在 package.json 声明 type: module 卷 3

这一组最容易混的三对

作用域 vs 闭包。 作用域是规则,闭包是这条规则产生的后果。函数在定义的地方决定自己能看见谁,这是作用域;函数被带走之后仍然记得那个范围,这是闭包。你没有"使用闭包"这个动作,只要写了嵌套函数,它就已经发生了。

同步 vs 异步。 同步是排队,上一行不跑完下一行不动;异步是先领号、回头再叫。setTimeout(fn, 0) 不是"立刻",它至少要等当前这段同步代码跑完。把异步当同步写,典型症状是"打印顺序和我写的不一样",而顺序问题只能靠事件循环解释,不能靠加 console.log 试出来。

冒泡 vs 委托。 冒泡是事件的传播路径,从最内层往外走;委托是利用这条路径,把监听器挂在父元素上统一处理。委托解决了"新增子元素没有监听器"的问题,但它依赖冒泡——某个子元素一旦调了 stopPropagation,父元素上的委托就收不到它。


④ 前端工程(16 条)

工程化这一组解决的是"从我这台机器能跑,到换台机器也能跑"。这里的词最容易混,因为它们描述的是同一条流水线上的不同工位:声明(package.json)、事实(lock)、加工(构建)、上桌(部署)。分不清工位,就会在错误的地方找问题——比如产物不对却去改依赖版本。

术语 一句话解释 常见误用 见哪一卷
npm Node 自带的包管理器,装包、跑脚本都靠它 把 npm 当成前端框架,以为装完就自动有了构建 卷 3
package.json 项目声明:叫什么、依赖什么、有哪些命令 手改了版本号却不更新 lock,CI 上 npm ci 直接失败 卷 3
lock 文件 记录整棵依赖树精确版本与内容哈希的清单 嫌它几千行碍眼就删掉,下次装出另一棵树,bug 复现不了 卷 3
semver 主.次.补丁 三段版本号,以及 ^ 与 ~ 的放行规则 以为 ^1.2.3 只升补丁,其实它能一路升到 2.0.0 之前 卷 3
依赖 你的代码运行时需要调用的、别人写的包 把构建工具装进 dependencies,线上白装几十兆无用代码 卷 3
devDependencies 只在开发、构建、测试阶段用到的包 把运行时库装成 -D,部署时 --omit=dev 一装就崩 卷 3
打包 把多个源文件合成少量可直接加载的产物 以为打包只是压缩,其实还要处理模块、别名和静态资源 卷 3
构建 把源码加工成可部署产物的一次性过程 在生产机上跑 dev 模式当正式服务,性能和稳定性都差一截 卷 3
开发服务器 本地起的、带转发和热更新的临时服务 把 dev server 当线上服务器,自己的电脑一关全站下线 卷 3
热更新 改文件后浏览器不刷新也能看到变化 以为热更新下正常就代表没问题,硬刷新后 bug 立刻复现 卷 3
tree-shaking 打包时删掉没有被任何地方引用到的代码 以为写了 import 就会被摇掉,带副作用的写法照样全量打进去 卷 3
环境变量注入 构建时把配置值替换进产物代码里的过程 以为在服务器上改 .env 前端就会变,值在构建时已经写死 卷 3
SPA 只加载一个 HTML、之后靠 JS 换页面的应用 以为 SPA 首屏一定快,其实要等 JS 下载并执行完才看得见 卷 4
SSR 请求到达时在服务器上把页面渲染成 HTML 再发 以为用了 SSR 就不用管客户端 JS,交互仍要靠 hydration 接上 卷 4
CSR 浏览器下载 JS 之后,自己在本地渲染出页面 把 CSR 当成"不需要服务器",静态托管和接口一样要服务器 卷 4
hydration 浏览器把事件和状态接到服务端送来的 HTML 上 首屏用了随机数或当前时间,两端算出两个值,直接报不一致 卷 4

这一组最容易混的三对

dependencies vs devDependencies。 前者是运行时要用的,后者只在开发、构建、测试时用。判断标准只有一句:这个包会不会被打进产物,或者线上运行时会不会被 import。装错位置不会当场报错,但部署时 --omit=dev 会让它在半夜崩,而且报错信息完全看不出是装错了位置。

打包 vs 构建。 构建是整条加工流程,打包是其中"把多个模块合成少量文件"这一步。构建还包括转译、压缩、处理静态资源、注入环境变量、生成哈希文件名。说"构建失败"通常指整条流程没走完,说"打包太大"只指产物体积——这两个问题要改的地方完全不同。

SPA vs SSR。 SPA 讲的是"页面切换由 JS 接管",SSR 讲的是"HTML 在服务器上先拼好"。两者不冲突:一个 SSR 应用也可以是 SPA,首屏由服务器给出,之后的路由仍然在浏览器里换。反过来说,SPA 不等于 CSR,静态导出的多页站点也不是 SPA。


⑤ 框架(14 条)

框架这一组的关键,是把"数据"和"界面"分开看。props 是外面给的,state 是自己记的,重渲染是用新数据重算界面,虚拟 DOM 是算完之后怎么最小代价地改真实页面。把这四件事分清楚,React 的一半报错会自己消失——它们本质上都是"数据从哪来、什么时候该变"的问题。

术语 一句话解释 常见误用 见哪一卷
组件 把一段界面和它的逻辑封成一个可复用的函数 把整个页面写成一个组件,改一处要读八百行才敢动手 卷 4
props 父组件传给子组件的只读参数 在子组件里直接改 props,想让父组件跟着变,结果不生效 卷 4
state 组件自己记住、变了要触发重渲染的数据 用普通变量存会变的值,改了以后界面一动不动 卷 4
受控组件 表单的值由 state 决定,输入即受控 输入框给了 value 却没给 onChange,直接变成只读 卷 4
副作用 渲染之外的事:取数、订阅、手动改 DOM 在渲染函数体里直接发请求,每次重渲染都多发一遍 卷 4
重渲染 组件函数被重新执行,用新数据算出新界面 以为重渲染等于重建 DOM,其实只 patch 有差异的节点 卷 4
虚拟 DOM 用普通对象描述界面,再比对差异去更新真实 DOM 以为虚拟 DOM 一定更快,单点修改手写反而快得多 卷 4
key 列表里帮框架认出"这一项还是不是原来那一项" 用数组下标当 key,删中间一项后输入框内容串到下一行 卷 4
路由 把 URL 映射到该显示哪个页面 以为路由只是换 URL,刷新后 404 说明服务端没配回退 卷 4
嵌套路由 父路径渲染外壳,子路径只换里面那块内容 每层都重写一遍导航和页脚,改一次要改五个文件 卷 4
服务端组件 只在服务器上跑、不进浏览器包的组件 在里面写 useState 或 onClick,构建阶段直接报错 卷 4
客户端组件 加了 use client、会进包并带交互的组件 在页面顶层加 use client,整棵树都退化成客户端渲染 卷 4
布局 多页之间共享、切换页面时不重新挂载的外壳 把登录校验写在布局里,以为每个子页都会重新执行一次 卷 4
静态导出 构建时把每个页面生成成 HTML,线上只发文件 动态路由没写 generateStaticParams 就开 export,构建失败 卷 4

这一组最容易混的三对

props vs state。 props 由父组件给,子组件只能读;state 由组件自己持有,改它必须调用专门的更新函数。把该放 state 的东西放成普通变量,界面不会动;把该由父级管的东西塞进 state,两个地方的数据就会打架,最后变成"谁后改谁赢"。

服务端组件 vs 客户端组件。 前者只在服务器上跑,不进浏览器包,所以不能用状态和事件;后者加了 'use client',会进包,能交互。判断标准不是"这个组件复杂不复杂",而是"它要不要在用户点击的时候还活着"。把 'use client' 加在页面顶层,等于让整棵树陪葬。

重渲染 vs 虚拟 DOM。 重渲染是组件函数重新执行一遍,虚拟 DOM 是把这次结果与上次比对、再决定改哪几处真实节点。重渲染不等于重建 DOM。这也是为什么 memo 有时有用、有时纯属噪音——它省的是函数执行,不是 DOM 操作,而性能瓶颈往往在后者之外。


⑥ 后端与接口(16 条)

接口这一组,是前后端唯一真正握手的地方。前四卷你可以靠"看起来对不对"判断,从这里开始必须靠状态码、报文和契约。这一组有一个共同背景:HTTP 是无状态的,所以每个请求都得自带足够的信息,服务端不能指望"上次那个请求"留下什么。

术语 一句话解释 常见误用 见哪一卷
API 两个程序之间约定好的调用方式与数据格式 把 API 当成数据库接口,以为前端直连库更省事 卷 5
REST 用 URL 表示资源、用方法表示动作的一套风格 把动作写进路径(/getNotes),还坚称自己是 REST 卷 5
端点 一个具体的 URL 加方法,如 POST /api/notes 把端点当成内部函数名,改路径不通知调用方 卷 5
路径参数 写在路径里的标识,如 /notes/42 里的 42 把该在路径里的 id 塞进查询串,缓存和日志都难读 卷 5
查询参数 URL 问号后面那串筛选、排序、分页条件 把令牌放查询串,被访问日志和浏览器历史完整记下 卷 5
请求体 请求里携带的主体数据,JSON 通常放这里 给 GET 硬塞 body,中间的代理和缓存直接把它丢掉 卷 5
状态码 三位数字,先告诉你这类结果属于哪一档 一出错全返回 200、在 body 里写 code,监控永远看不见故障 卷 5
幂等 同样的请求发多次,结果与发一次相同 把 POST 创建当幂等,加了重试,用户双击就多两条记录 卷 5
鉴权 判断"你能不能做这件事" 只在前端隐藏按钮,接口照样谁都能调,等于没做 卷 6
认证 判断"你是谁" 把认证当鉴权,以为登录了就能看所有人的数据 卷 6
令牌 服务端发的、客户端每次带上来自证身份的字符串 把令牌当密码存进 localStorage,还顺手打进日志 卷 6
Cookie 浏览器按域名自动保存并回传的一小段键值 以为设了 Cookie 所有子域都能用,其实默认只当前域 卷 6
Session 存在服务端的一张会话表,客户端只拿编号 以为登出删掉浏览器 Cookie 就够了,服务端记录还在 卷 6
CORS 浏览器替服务器把关,决定跨源响应能否交给 JS 以为 CORS 是服务器安全机制,其实它保护的是别的网站的用户 卷 5
预检请求 跨源非简单请求之前先发的 OPTIONS 探路 日志里没有真实请求就断定前端没发,其实预检就没过 卷 5
限流 对单位时间内的请求次数设上限 只按 IP 限流,一个办公室共用一个出口 IP,互相拖累 卷 7

这一组最容易混的三对

认证 vs 鉴权。 认证回答"你是谁",鉴权回答"你能不能动这条数据"。登录成功只完成了认证;拿着自己的令牌去读别人的摘录,认证没问题,鉴权失败了。绝大多数"功能全对、数据全泄"的漏洞,都出在只做了前者——因为前者有现成的登录页,后者要在每个接口里多写一行条件。

Cookie vs Session。 Cookie 是浏览器替你保管并自动回传的一小段键值,Session 是服务端那张记录"谁登录了"的表。Cookie 里装的通常只是 Session 的编号。删掉 Cookie 不等于注销会话:服务端那行还在,把 Cookie 复制出来用 curl -b 再请求,照样 200。

路径参数 vs 查询参数。 路径参数标识"哪一个资源",如 /notes/42;查询参数描述"怎么筛、怎么排",如 ?tag=认知&page=2。把筛选条件写进路径会让缓存和日志难读,把身份标识塞进查询串则会被完整记进访问日志——这两种错都不会立刻报错,只会在某天被人翻出来。


⑦ 数据(14 条)

数据这一组的分量在于:前面所有错误都能刷新重来,这一组错了往往不可逆。表结构、事务边界、备份方式,这三件事在项目小的时候看不出差别;数据一多、并发一来,代价一次性结算。这一组的词要连着读,因为它们互相约束:主键决定外键,外键影响索引,索引影响事务里的锁。

术语 一句话解释 常见误用 见哪一卷
表 数据库里按固定字段存同类记录的结构 一张表塞所有类型的数据,靠一个 type 字段区分 卷 6
行 表里的一条完整记录 把行当成一行文本,忘了每个字段都有类型和约束 卷 6
列 表里一个字段的定义,规定类型与约束 用文本存日期,排序和比较全靠字符串的巧合 卷 6
主键 唯一标识一行的字段,不能重复也不能为空 用邮箱当主键,用户一改邮箱就要连带改一串外键 卷 6
外键 指向另一张表主键的字段,用来保证引用有效 以为建了外键就自动有索引,删除时悄悄全表扫描 卷 6
索引 为某列额外维护的查找结构,换来更快的查询 给每一列都建索引,写入变慢、库文件还变大 卷 6
事务 一组要么全成、要么全不成的写操作 事务里发 HTTP 请求,外部一超时就把整段写锁拖死 卷 6
回滚 事务失败时,把已经做过的改动全部撤销 以为出错会自动回滚,其实连接是自动提交,早写进去了 卷 6
迁移 用可重复执行的脚本演进表结构 直接手工改线上表,代码和库结构对不上,查半天 卷 6
连接池 预先维持一批数据库连接,反复使用 每个请求新建连接,并发一高就把连接数打满 卷 6
N+1 查一次列表后,又为每条记录各查一次 列表页只测了 3 条数据,上线 300 条直接超时 卷 8
注入 把用户输入当代码拼进查询,改变了原意 用字符串拼接再手工转义引号,以为这样就安全了 卷 6
参数化查询 把语句和值分开传给数据库执行 以为用了 ORM 就免疫注入,原生拼接照样中招 卷 6
备份 数据的一份可恢复副本,演练过才算数 直接 cp 正在写的 SQLite 文件,恢复时发现是坏库 卷 7

这一组最容易混的三对

主键 vs 外键。 主键标识本表的一行,唯一且非空;外键是指向另一张表主键的字段,用来保证"这条记录引用的用户真的存在"。主键是身份,外键是关系。用业务字段(邮箱、手机号)当主键,等它要改的那天,你会同时改一串外键,还得担心改到一半失败。

事务 vs 回滚。 事务是一次"打包提交"的边界,回滚是这次打包失败后的撤销动作。事务不等于自动回滚:连接处于自动提交模式时,每条语句各自生效,你以为包住了,其实早就写进去了。判断办法很土但有效——在事务中间故意抛一个异常,看数据到底在不在。

注入 vs 参数化查询。 注入是把用户输入当代码拼进语句,参数化查询是把语句和值分开送。参数化不是"更安全的字符串拼接",它让数据库先编译语句、再填值,值永远只能当值。用了 ORM 也不自动免疫,只要有一处原生拼接,那一处就是缺口。


⑧ 上线与运维(12 条)

上线这一组的分界线很清楚:在这之前,东西只在你电脑上;在这之后,它属于互联网。这一组的词大多不是"功能",而是"出事时能不能救回来"——常驻、日志、证书、备份、回滚,全都是为失败准备的。你可以不做灰度,但不能不知道回滚怎么做。

术语 一句话解释 常见误用 见哪一卷
部署 把本地代码变成线上可访问服务的一整套动作 以为部署就是上传文件,忘了装依赖、配环境变量、起进程 卷 7
反向代理 站在服务器前面接请求,再转给内部应用 以为反代会自动改写响应里的地址,跳转仍指向内网 卷 7
正向代理 替客户端出面的代理,服务端只看到代理 把公司上网代理和 Nginx 反代混为一谈,配置思路全错 卷 7
负载均衡 把请求分给多台后端,避免一台扛全部 会话存在单机内存里就上多台,用户一刷新就掉登录 卷 7
systemd Linux 上管服务启停、开机自启与崩溃重启 用 nohup 起服务就算完事,服务器一重启全没了 卷 7
守护进程 脱离终端在后台长期运行、不随登录退出的进程 以为进程在跑就不会死,没配重启策略,崩了没人知道 卷 7
日志轮转 按大小或日期切分旧日志并清理 日志只追加不切分,几个月后磁盘满,整站写不进去 卷 7
证书链 服务器证书、中间证书、根证书逐级签名 只配了服务器证书、缺中间证书,部分手机直接打不开 卷 7
自动续期 让证书在到期前自动换新,不靠人记日子 配了续期任务却没重载 Nginx,新证书躺着没生效 卷 7
健康检查 用一个固定端点判断服务是否真的可用 检查只返回 200 不查数据库,库挂了它仍判健康 卷 7
回滚 出问题时切回上一个能用的版本 代码直接 git pull 到工作目录,回滚只能 reset --hard 赌一把 卷 7
灰度 先让一小部分用户用新版本,确认后再全量 没有版本目录和流量切分就谈灰度,出事只能全站回滚 卷 7

这一组最容易混的三对

正向代理 vs 反向代理。 正向代理替客户端出面,服务端只知道代理,不知道你;反向代理替服务器出面,你只知道域名,不知道后面有几台机器。Nginx 在这本书里是反代:它收证书、转请求,后端只监听回环地址。把两者混着理解,配置里的 proxy_pass 就永远像一句咒语。

systemd vs 守护进程。 守护进程是"脱离终端、在后台长期活着"的进程状态;systemd 是管这件事的工具,负责开机自启、崩溃重启、日志归集。用 nohup 起一个后台进程,只满足了"现在活着",没满足"下次开机还活着",更没满足"崩了自动起来"。

回滚(数据) vs 回滚(版本)。 数据库的回滚是撤销一次未提交的事务,用 ROLLBACK;发布回滚是把线上切回上一个版本,靠版本目录加一条切换命令。发布回滚最怕代码是直接 git pull 到工作目录的——那时你只有"改回去",没有"切回去",而改回去的过程中手一抖就是二次事故。


缩写速查(32 条)

这张表解决"看到一串大写字母不知道在说什么"的问题。全称给的是展开后的英文,中文一句是你判断"要不要继续查"的依据。读法见前文第三节;这里只提醒一点:别的领域可能有同名缩写,含义完全不同,套用之前先确认语境。本书只用下表这一种含义。

缩写 全称 一句中文
HTML HyperText Markup Language 描述页面结构的标记语言
CSS Cascading Style Sheets 管外观与布局的样式表语言
JS JavaScript 浏览器里跑的动态脚本语言
TS TypeScript 给 JS 加上静态类型的超集
DOM Document Object Model 浏览器把 HTML 解析成的节点树
API Application Programming Interface 程序之间约定好的调用方式
REST Representational State Transfer 用 URL 和方法表达资源的接口风格
JSON JavaScript Object Notation 前后端都认的键值对文本格式
HTTP HyperText Transfer Protocol 明文传输网页报文的协议
HTTPS HTTP Secure 把 HTTP 放进 TLS 里传输
TLS Transport Layer Security 提供加密与身份验证的传输层协议
DNS Domain Name System 把域名翻译成 IP 的系统
TCP Transmission Control Protocol 保证按序到达、丢了重发的传输协议
IP Internet Protocol 给每台联网设备编址的网络层协议
URL Uniform Resource Locator 能定位到具体资源的完整地址
URI Uniform Resource Identifier 标识一个资源的字符串,比 URL 更宽
SPA Single Page Application 只加载一次 HTML、之后靠 JS 换页的应用
SSR Server-Side Rendering 请求到达时在服务器上渲染出 HTML
CSR Client-Side Rendering 浏览器下载 JS 后在本地渲染页面
SSG Static Site Generation 构建时把页面预生成成静态 HTML
CI/CD Continuous Integration / Continuous Delivery 自动构建测试并交付版本的流水线
ORM Object-Relational Mapping 把表映射成对象、用代码代替 SQL 的层
SQL Structured Query Language 关系数据库的查询语言
WAL Write-Ahead Logging 先写日志再改数据的机制,SQLite 靠它提并发
JWT JSON Web Token 自带签名、可自证的令牌格式
CORS Cross-Origin Resource Sharing 服务器声明哪些外源可以读我
CSRF Cross-Site Request Forgery 借用户已登录的 Cookie 伪造请求
XSS Cross-Site Scripting 把脚本注入页面、在别人浏览器里执行
IDOR Insecure Direct Object Reference 只靠改 id 就访问到别人的数据
FCP First Contentful Paint 首屏出现第一块内容的时间
TTFB Time To First Byte 从发出请求到收到第一个字节的时间
P95 95th Percentile 把请求按耗时排序后第 95% 位的值

怎么用这张表复习

不要按顺序读第二遍。更划算的做法是三轮,每轮只做一件事。

第一轮,遮住第二列。 看术语名,自己说一句它是什么,说完再看。说不出来不要紧,能说出"我在哪一章见过它"也算过——位置记忆比定义记忆牢,而且更容易长回来。

第二轮,只读第三列。 把 120 条"常见误用"当故事看,一条一条问自己"这个错我犯过没有"。犯过的在旁边打个勾,这些勾就是你的薄弱点,比任何自测分数都准。没犯过的也别跳过,它们大概率还没轮到。

第三轮,从错误反查术语。 拿你项目里真实遇到的三个报错,回到表里找对应的行,看"见哪一卷",去读那一章。三轮下来,这张表就不再是清单,而是一张你自己画过的地图——上面的每一条路,你都走过一次。

最后一个提醒:术语是用来缩短沟通的,不是用来显得专业的。跟人讨论时,如果对方愣了一下,就把缩写展开、把术语换成人话。能把 hydration 解释成"浏览器给服务端送来的 HTML 通电",比正确念出它更有用。