phase 5 part 1: typescript, vue, react, ssr(Next.js 16) topics with lessons, scenarios, interviews, verified examples

This commit is contained in:
Shikui Wang committed 2026-10-23 16:24:06 +08:00
1 parent 7a32d2c9a6
commit 7b5cae7d24
39 files changed
+2482 -48

No files matched your search

@@ -0,0 +1,119 @@
---
id: frontend.vue.reactivity-composition
title: Vue 3 响应式原理、组合式函数、Pinia 和性能优化
type: lesson
domain: frontend
stack: [vue]
tags: [Vue 3, 响应式, Proxy, ref, reactive, computed, watch, 组合式函数, Pinia, 性能]
level: intermediate
prerequisites: [frontend.typescript.type-system]
est_hours: 3
related: [frontend.vue.scenario.ai-chat-stream, frontend.react.index, frontend.vue.interview]
week: [7]
order: 1
---
# Vue 3 响应式原理、组合式函数、Pinia 和性能优化
> 基于 Vue 3.5 编写,以官方文档为准:https://cn.vuejs.org/
## 解释说明
### 响应式原理(面试必问)
- `reactive()` 用 **Proxy** 拦截对象的读写:读取时**收集依赖**(当前正在运行的副作用:组件渲染、`computed`、`watch`),写入时**触发**依赖重新执行。
- `ref()` 用对象的 `.value` getter / setter 实现,可以包装基本类型;模板中自动解包。
- `computed` 是带缓存的副作用:依赖不变就不重新计算。
- 更新是**异步批量**的:同一轮中多次修改只触发一次渲染,`await nextTick()` 之后才能拿到更新后的 DOM。
- Vue 2 用 `Object.defineProperty`,无法检测新增属性和数组索引赋值;Vue 3 的 Proxy 解决了这个问题。
| API | 用途 | 注意 |
| --- | --- | --- |
| `ref` / `reactive` | 响应式状态 | `reactive` 解构会丢失响应性,用 `toRefs`;整体替换 `reactive` 对象会断开引用 |
| `shallowRef` | 只追踪 `.value` 的替换 | 大对象、第三方实例、只整体替换的数据,性能更好 |
| `computed` | 派生状态 | 不要在里面做副作用 |
| `watch` / `watchEffect` | 副作用(请求、存储) | 异步副作用要处理竞态(`onWatcherCleanup` / `onCleanup`) |
| `effectScope` / `onScopeDispose` | 管理一组副作用的生命周期 | 组合式函数里清理定时器、请求、订阅 |
### 组合式函数(Composables)
把有状态的逻辑封装成 `useXxx()`:内部用 `ref`、`watch`、生命周期钩子,返回响应式状态和方法。和 React Hooks 的区别:`setup` 只执行一次,没有“依赖数组”和闭包陈旧值的问题,但要注意返回值的响应性和副作用清理。
### Pinia
官方状态管理:`defineStore`,支持组合式写法;store 解构要用 `storeToRefs`;服务端渲染时每个请求要有独立的 Pinia 实例,避免跨请求状态污染。
### 性能
`v-memo`、`v-once`;长列表虚拟滚动;大对象用 `shallowRef` / `markRaw`;组件懒加载 `defineAsyncComponent`;`computed` 代替模板中的复杂表达式;避免在模板中创建新对象 / 函数导致子组件重复渲染。
## 案例
AI 对话页面:流式输出时每秒几十次追加文本,最初用 `reactive` 存整个消息数组并且每次替换,导致长对话卡顿。改为:已完成的消息用 `shallowRef` 数组(完成后整体替换一次),正在生成的消息单独用一个 `ref` 追加文本;Markdown 渲染做节流。把请求、解析、状态机封装成 `useChatStream` 组合式函数,组件卸载时自动停止生成。
## 代码示例
组合式函数的核心(完整版本 [examples/ai-chat-stream/useChatStream.ts](examples/ai-chat-stream/useChatStream.ts),带 vitest 测试):
```ts
export function useChatStream(opts: ChatOptions) {
const status = ref<ChatStatus>("idle");
const text = ref("");
const final = shallowRef<FinalPayload | null>(null); // 整体替换的对象用 shallowRef
let controller: AbortController | null = null;
async function send(question: string) {
controller?.abort(); // 新问题:取消上一次
controller = new AbortController();
status.value = "connecting";
const resp = await fetch(opts.url, { method: "POST", body: JSON.stringify({ question }), signal: controller.signal });
status.value = "streaming";
const feed = createSSEParser((e) => {
if (e.event === "token") text.value += e.data;
else if (e.event === "final") final.value = parseFinal(e.data);
});
const reader = resp.body!.pipeThrough(new TextDecoderStream()).getReader();
for (;;) {
const { value, done } = await reader.read();
if (done) break;
feed(value);
}
status.value = "done";
}
onScopeDispose(() => controller?.abort()); // 组件卸载时停止,避免泄漏
return { status: readonly(status), text: readonly(text), final, send, stop: () => controller?.abort() };
}
```
在组件中使用:
```vue
<script setup lang="ts">
import { useChatStream } from "./useChatStream";
const { status, text, final, send, stop } = useChatStream({ url: "/api/chat" });
</script>
<template>
<p v-if="status === 'connecting'">连接中…</p>
<article>{{ text }}</article>
<ul v-if="final"><li v-for="c in final.citations" :key="c.id">{{ c.title }}</li></ul>
<button v-if="status === 'streaming'" @click="stop">停止生成</button>
</template>
```
## 易错点
- 解构 `reactive` 对象或 Pinia store 后丢失响应性。
- `watch` 一个 `reactive` 对象的属性时写成 `watch(obj.count, ...)`:应该传 getter `() => obj.count`。
- 异步 `watch` 没有处理竞态:快速切换时旧请求的结果覆盖新结果。
- 在组合式函数里注册了定时器 / 订阅,没有在作用域销毁时清理。
- 用 `v-html` 渲染模型输出的 Markdown,没有做 XSS 清洗(见 [Web 安全专题](../../cs/web-security/index.md))。
- 把大量第三方对象(图表实例、编辑器)放进 `reactive`,造成深度代理的性能开销。
## 面试常问
- Vue 3 的响应式原理?和 Vue 2 有什么区别?
- `ref` 和 `reactive` 的区别?
- `computed` 和 `watch` 的区别?
- 组合式函数和 React Hooks 有什么区别?
@@ -0,0 +1 @@
{"type":"module"}
@@ -0,0 +1,25 @@
// 运行:node sse-demo.ts —— 验证解析器能处理被切开的分块、多行 data、心跳注释
import { createSSEParser, parseFinal, type SSEEvent } from "./sse.ts";
const events: SSEEvent[] = [];
const feed = createSSEParser((e) => events.push(e));
const stream = [
": ping\n\n",
"id: 1\nevent: progress\ndata: {\"step\":\"检索资料\"}\n\n",
"id: 2\nevent: token\ndata: 签收 7 天内",
"可以无理由退货\n\nid: 3\nevent: tok",
"en\ndata: 。\n\n",
"id: 4\nevent: final\ndata: {\"answer\":\"签收 7 天内可以无理由退货。\",\n",
"data: \"citations\":[{\"id\":1,\"title\":\"退货政策\"}]}\n\n",
];
for (const chunk of stream) feed(chunk);
console.log(events.map((e) => `${e.id}:${e.event}`).join(" "));
const text = events.filter((e) => e.event === "token").map((e) => e.data).join("");
const last = events.at(-1);
const final = last ? parseFinal(last.data) : null;
console.log("拼接文本:", text, "引用:", final?.citations);
if (text !== "签收 7 天内可以无理由退货。" || events.length !== 4 || final?.citations[0]?.title !== "退货政策") {
throw new Error("断言失败");
}
@@ -0,0 +1,51 @@
// 增量 SSE 解析器:网络分块可能把一个事件切成两半,必须缓冲到空行再解析。
// 浏览器的 EventSource 只支持 GET 且不能带自定义请求头,AI 对话通常用 fetch + POST,再自己解析 SSE。
// 格式参考 HTML 标准:https://html.spec.whatwg.org/multipage/server-sent-events.html
export interface SSEEvent {
event: string; // 默认 "message"
data: string;
id?: string;
}
export function createSSEParser(onEvent: (e: SSEEvent) => void) {
let buffer = "";
return (chunk: string): void => {
buffer += chunk.replace(/\r\n?/g, "\n");
let sep: number;
while ((sep = buffer.indexOf("\n\n")) >= 0) {
const block = buffer.slice(0, sep);
buffer = buffer.slice(sep + 2);
const ev: SSEEvent = { event: "message", data: "" };
const data: string[] = [];
for (const line of block.split("\n")) {
if (!line || line.startsWith(":")) continue; // 空行、注释(常用作心跳)
const i = line.indexOf(":");
const field = i < 0 ? line : line.slice(0, i);
const value = i < 0 ? "" : line.slice(i + 1).replace(/^ /, "");
if (field === "event") ev.event = value;
else if (field === "data") data.push(value);
else if (field === "id") ev.id = value;
}
if (data.length) {
ev.data = data.join("\n");
onEvent(ev);
}
}
};
}
// 对话任务的状态:前端据此显示“连接中 / 生成中 / 完成 / 失败(可重试)/ 已停止”
export type ChatStatus = "idle" | "connecting" | "streaming" | "done" | "error" | "aborted";
// 服务端约定的事件:token(增量文本)、progress(任务进度)、final(结构化结果)、error
export interface FinalPayload {
answer: string;
citations: { id: number; title: string }[];
}
export function parseFinal(data: string): FinalPayload {
const v = JSON.parse(data) as Partial<FinalPayload>;
if (typeof v.answer !== "string" || !Array.isArray(v.citations)) throw new Error("final 事件格式错误");
return { answer: v.answer, citations: v.citations };
}
@@ -0,0 +1,57 @@
// 不自动运行(需要 npm i -D vitest vue 后执行 npx vitest run)
import { describe, expect, it } from "vitest";
import { effectScope } from "vue";
import { useChatStream } from "./useChatStream.ts";
function sseResponse(chunks: string[], failAfter?: number): Response {
let i = 0;
const body = new ReadableStream<Uint8Array>({
pull(ctrl) {
if (failAfter !== undefined && i === failAfter) return ctrl.error(new Error("network down"));
if (i >= chunks.length) return ctrl.close();
ctrl.enqueue(new TextEncoder().encode(chunks[i++]));
},
});
return new Response(body, { status: 200, headers: { "Content-Type": "text/event-stream" } });
}
const FINAL = 'id: 3\nevent: final\ndata: {"answer":"好","citations":[{"id":1,"title":"政策"}]}\n\n';
describe("useChatStream", () => {
it("拼接 token 并解析 final", async () => {
const scope = effectScope();
const chat = scope.run(() =>
useChatStream({ url: "/chat", fetchImpl: async () => sseResponse(["id: 1\nevent: token\ndata: 你", "好\n\n", FINAL]) }),
)!;
await chat.send("hi");
expect(chat.status.value).toBe("done");
expect(chat.text.value).toBe("你好");
expect(chat.final.value?.citations[0]?.title).toBe("政策");
scope.stop();
});
it("断线后带 Last-Event-ID 重试", async () => {
const seen: (string | null)[] = [];
let n = 0;
const fetchImpl = async (_: RequestInfo | URL, init?: RequestInit) => {
seen.push(new Headers(init?.headers).get("Last-Event-ID"));
return n++ === 0 ? sseResponse(["id: 1\nevent: token\ndata: 你\n\n", "x"], 1) : sseResponse([FINAL]);
};
const chat = useChatStream({ url: "/chat", fetchImpl, maxRetries: 1 });
await chat.send("hi");
expect(seen).toEqual([null, "1"]);
expect(chat.status.value).toBe("done");
});
it("stop 之后状态为 aborted", async () => {
const fetchImpl = (_: RequestInfo | URL, init?: RequestInit) =>
new Promise<Response>((_, reject) =>
init?.signal?.addEventListener("abort", () => reject(new DOMException("aborted", "AbortError"))),
);
const chat = useChatStream({ url: "/chat", fetchImpl });
const p = chat.send("hi");
chat.stop();
await p;
expect(chat.status.value).toBe("aborted");
});
});
@@ -0,0 +1,85 @@
// 不自动运行(依赖 vue,需要 npm install 后用 vitest 运行 useChatStream.test.ts)
// Vue 3 组合式函数:POST + 流式读取、状态机、停止生成、断线后带 Last-Event-ID 重试。
import { ref, shallowRef, readonly, onScopeDispose } from "vue";
import { createSSEParser, parseFinal, type ChatStatus, type FinalPayload } from "./sse.ts";
export interface ChatOptions {
url: string;
fetchImpl?: typeof fetch;
maxRetries?: number;
}
export function useChatStream(opts: ChatOptions) {
const status = ref<ChatStatus>("idle");
const text = ref("");
const progress = ref("");
const final = shallowRef<FinalPayload | null>(null);
const error = ref("");
let controller: AbortController | null = null;
let lastEventId: string | undefined;
const doFetch = opts.fetchImpl ?? fetch;
async function send(question: string, attempt = 0): Promise<void> {
if (attempt === 0) {
controller?.abort(); // 新问题:取消上一次的生成
text.value = "";
final.value = null;
error.value = "";
lastEventId = undefined;
}
controller = new AbortController();
status.value = "connecting";
try {
const resp = await doFetch(opts.url, {
method: "POST",
headers: { "Content-Type": "application/json", ...(lastEventId ? { "Last-Event-ID": lastEventId } : {}) },
body: JSON.stringify({ question }),
signal: controller.signal,
});
if (!resp.ok || !resp.body) throw new Error(`HTTP ${resp.status}`);
status.value = "streaming";
const feed = createSSEParser((e) => {
if (e.id) lastEventId = e.id; // 记录进度,断线重连时服务端从这里继续
if (e.event === "token") text.value += e.data;
else if (e.event === "progress") progress.value = JSON.parse(e.data).step;
else if (e.event === "final") final.value = parseFinal(e.data);
else if (e.event === "error") throw new Error(e.data);
});
const reader = resp.body.pipeThrough(new TextDecoderStream()).getReader();
for (;;) {
const { value, done } = await reader.read();
if (done) break;
feed(value);
}
status.value = final.value ? "done" : "error";
if (!final.value) error.value = "连接提前结束";
} catch (e) {
if ((e as Error).name === "AbortError") {
status.value = "aborted";
return;
}
if (attempt < (opts.maxRetries ?? 2)) {
await new Promise((r) => setTimeout(r, 300 * 2 ** attempt));
return send(question, attempt + 1);
}
status.value = "error";
error.value = (e as Error).message;
}
}
function stop() {
controller?.abort();
}
onScopeDispose(stop); // 组件卸载时停止,避免泄漏和继续计费
return {
status: readonly(status),
text: readonly(text),
progress: readonly(progress),
final,
error: readonly(error),
send,
stop,
};
}
+30 -5
View File
@@ -1,15 +1,40 @@
---
id: frontend.vue.index
title: Vue 3 + Pinia + Router
title: Vue 3
type: index
domain: frontend
stack: [vue]
tags: []
tags: [Vue 3, 响应式, 组合式函数, Pinia, AI 对话界面]
week: [7]
---
# Vue 3 + Pinia + Router
# Vue 3
响应式、组合式 API、状态管理、路由与权限。
你的强项,这里重点是面试常问的原理和“AI 原生前端”的实践(流式渲染、任务状态、断线续传)。BOSS直聘 2026-10-23 的调研中约 14 个岗位要求 Vue / React。
> 本专题建设中:课程、企业场景、面试题和示例代码会陆续补充。
## 学习路线
| 顺序 | 课程 | 级别 | 预计 |
| --- | --- | --- | --- |
| 1 | [Vue 3 响应式原理、组合式函数、Pinia 和性能优化](01-reactivity-composition.md) | 进阶 | 3 小时 |
## 企业场景
- [AI 对话界面:流式渲染、任务状态、停止生成和断线续传](scenarios/ai-chat-stream.md)
## 面试题
- [Vue 面试题](interview.md)
## 示例代码
- [examples/ai-chat-stream](examples/ai-chat-stream/):增量 SSE 解析器(`node sse-demo.ts` 运行)、`useChatStream` 组合式函数(状态机、停止、`Last-Event-ID` 重试)和 vitest 测试(需要 `npm i -D vitest vue`)
## 在 16 周计划中
- [第 7 周:前端工程化查漏](../../../plan/week07-frontend.md)、[第 12 周:SSE 进度推送](../../../plan/week12-agent-m3-persistence.md)
## 官方资料
- https://cn.vuejs.org/
- Pinia:https://pinia.vuejs.org/zh/
+67
View File
@@ -0,0 +1,67 @@
---
id: frontend.vue.interview
title: Vue 面试题
type: interview
domain: frontend
stack: [vue]
tags: [Vue 3, 响应式, Pinia, 面试]
level: intermediate
related: [frontend.vue.reactivity-composition]
week: [7, 16]
---
# Vue 面试题
## 基础
### 【基础】Vue 3 的响应式原理是什么?
**参考答案**:`reactive` 用 Proxy 拦截读写,读取时把当前运行的副作用(渲染函数、computed、watch)记录为依赖,写入时触发这些副作用重新执行;`ref` 通过 `.value` 的访问器实现。更新是异步批量的,同一轮修改只渲染一次。
**追问**:和 Vue 2 有什么区别?→ Vue 2 用 `Object.defineProperty`,需要初始化时递归转换,无法检测新增属性和数组索引修改;Proxy 可以拦截这些操作,并且是惰性代理。
### 【基础】`ref` 和 `reactive` 有什么区别?
**参考答案**:`ref` 可以包装任何值,通过 `.value` 访问,模板中自动解包,可以整体替换;`reactive` 只能用于对象,直接访问属性,解构会丢失响应性,整体替换会断开引用。很多团队统一用 `ref`。
**追问**:解构 Pinia store 怎么保持响应性?→ 用 `storeToRefs(store)` 解构状态和 getter,方法直接从 store 解构。
### 【基础】`computed` 和 `watch` 的区别?
**参考答案**:`computed` 用于派生值,有缓存,依赖不变不重新计算,不应有副作用;`watch` 用于响应变化执行副作用(请求、写存储),可以拿到新旧值、控制立即执行和深度监听。
**追问**:`watch` 和 `watchEffect` 的区别?→ `watch` 显式指定数据源、惰性执行;`watchEffect` 自动收集依赖、立即执行一次。
## 进阶
### 【进阶】组合式函数和 React Hooks 有什么区别?
**参考答案**:Vue 的 `setup` 只执行一次,响应式系统自动追踪依赖,没有依赖数组和闭包陈旧值问题,也没有“Hooks 必须按顺序调用”的限制;React 组件每次渲染都执行函数体,靠依赖数组和 memo 控制。Vue 组合式函数要注意返回值保持响应性和副作用清理。
**追问**:组合式函数里怎么清理副作用?→ `onScopeDispose` 或 `onUnmounted` 中取消请求、清除定时器;`watch` 的清理回调处理竞态。
### 【进阶】`nextTick` 的作用和原理?
**参考答案**:Vue 把 DOM 更新放进异步队列批量执行,`nextTick` 返回一个在下一次 DOM 更新完成后 resolve 的 Promise(基于微任务),用于在修改数据后读取更新后的 DOM。
**追问**:为什么要批量异步更新?→ 避免同一轮中多次修改导致多次渲染,提高性能。
### 【进阶】Vue 应用有哪些性能优化手段?
**参考答案**:路由和组件懒加载;长列表虚拟滚动;`shallowRef` / `markRaw` 减少深度代理;`v-memo`、`v-once`;`computed` 缓存;避免不必要的组件重渲染(稳定的 props);按需引入组件库;图片懒加载和压缩;构建层面的拆包。
**追问**:怎么定位是哪个组件渲染慢?→ Vue DevTools 的性能面板、浏览器 Performance 面板录制,查看组件渲染耗时和次数。
## 场景题
### 【场景题】做一个 AI 对话界面,流式输出要注意什么?
**参考答案**:fetch + 增量 SSE 解析(POST、鉴权头);状态机;停止生成和卸载时取消;断线带 `Last-Event-ID` 续传;结构化的 final 事件返回引用;渲染节流和 XSS 清洗;网关关闭缓冲。详见[AI 对话界面场景](scenarios/ai-chat-stream.md)。
**追问**:为什么不用 EventSource?→ 只支持 GET、不能自定义请求头,问题内容和令牌不适合放在 URL 中。
### 【场景题】一个后台表格页面有 1 万行数据,滚动很卡,怎么优化?
**参考答案**:虚拟滚动只渲染可见行;数据用 `shallowRef` 存放;行组件保持 props 稳定、减少响应式开销;能分页就分页(服务端分页);复杂单元格延迟渲染;排序筛选放到 Web Worker 或服务端。
**追问**:虚拟滚动的原理?→ 根据滚动位置和行高计算可见范围,只渲染这一段,用占位高度撑开滚动条;行高不固定时需要测量和缓存高度。
@@ -0,0 +1,96 @@
---
id: frontend.vue.scenario.ai-chat-stream
title: AI 对话界面:流式渲染、任务状态、停止生成和断线续传
type: scenario
domain: frontend
stack: [vue, typescript, fastapi, nginx]
tags: [流式输出, SSE, 任务状态, 断线重连, Last-Event-ID, 结构化输出, AI 原生前端]
level: advanced
prerequisites: [frontend.vue.reactivity-composition]
est_hours: 3
related: [frontend.vue.interview, python.fastapi.scenario.streaming-chat-api, devops.nginx.scenario.ai-gateway-sse-canary]
week: [7, 12]
---
# AI 对话界面:流式渲染、任务状态、停止生成和断线续传
## 业务背景与问题
企业知识库助手的前端(Vue 3),用户反馈:
1. 回答要等十几秒才一次性出现;
2. 回答到一半网络抖动,整段内容丢失,只能重新提问(重新计费);
3. 用户切换页面后,后台还在生成,浪费额度;
4. 不知道助手在做什么(检索?调用工具?);
5. 引用来源和答案混在文本里,无法点击跳转。
BOSS直聘 2026-10-23 的调研中,“AI 原生前后端”(流式、结构化输出、任务状态、异常恢复)是反复出现的要求,这个场景就是它的典型落地。
## 约束
- 需要 POST 请求携带问题和鉴权头(浏览器的 `EventSource` 只支持 GET、不能自定义请求头)。
- 经过 Nginx 网关。
## 方案设计
1. **事件协议**(前后端约定):`progress`(当前步骤:检索、调用工具)、`token`(增量文本)、`final`(结构化结果:答案 + 引用列表)、`error`;每个事件带递增的 `id`。
2. **前端**:`fetch` + `ReadableStream` 读取,增量 SSE 解析器(处理分块边界);状态机 `idle → connecting → streaming → done / error / aborted`,界面按状态显示。
3. **停止生成**:`AbortController` 取消请求;组件卸载时自动取消;后端检测到断开后停止调用模型。
4. **断线续传**:前端记录最后的事件 `id`,重试时带 `Last-Event-ID` 请求头;后端把生成中的事件缓存一段时间(例如 Redis 中按会话保存),从该 ID 之后继续发送,而不是重新生成。重试次数有限,带退避。
5. **结构化结果**:引用来源通过 `final` 事件以 JSON 返回,前端渲染成可点击的卡片,而不是从文本里正则提取。
6. **渲染性能**:正在生成的消息单独存放,Markdown 渲染节流;渲染前做 XSS 清洗。
7. **网关**:Nginx 关闭代理缓冲(见 [Nginx SSE 场景](../../../devops/nginx/scenarios/ai-gateway-sse-canary.md))。
## 关键代码
增量解析器(完整版本 [examples/ai-chat-stream/sse.ts](../examples/ai-chat-stream/sse.ts),`node sse-demo.ts` 验证分块切开、多行 data、心跳注释):
```ts
export function createSSEParser(onEvent: (e: SSEEvent) => void) {
let buffer = "";
return (chunk: string): void => {
buffer += chunk.replace(/\r\n?/g, "\n");
let sep: number;
while ((sep = buffer.indexOf("\n\n")) >= 0) { // 一个事件以空行结束
const block = buffer.slice(0, sep);
buffer = buffer.slice(sep + 2);
// 解析 event / data / id 字段,忽略以 ":" 开头的注释(心跳)……
}
};
}
```
断线重试([useChatStream.ts](../examples/ai-chat-stream/useChatStream.ts)):
```ts
headers: { "Content-Type": "application/json", ...(lastEventId ? { "Last-Event-ID": lastEventId } : {}) },
...
if (attempt < (opts.maxRetries ?? 2)) {
await new Promise((r) => setTimeout(r, 300 * 2 ** attempt));
return send(question, attempt + 1);
}
```
测试([useChatStream.test.ts](../examples/ai-chat-stream/useChatStream.test.ts))覆盖:拼接 token 和解析 final、断线后带 `Last-Event-ID` 重试、停止后状态为 aborted。
## 取舍
| 选择 | 优点 | 缺点 |
| --- | --- | --- |
| **fetch + 自己解析 SSE(本方案)** | 支持 POST、鉴权头、取消 | 要自己处理解析和重连 |
| EventSource | 浏览器自动重连、自动带 Last-Event-ID | 只支持 GET,不能自定义请求头 |
| WebSocket | 双向通信 | 对“一问一答流式返回”来说过重;网关和鉴权更复杂 |
| 轮询 | 简单 | 延迟高、请求多 |
## 易错点
- 按网络分块直接 `JSON.parse`,分块切在事件中间就报错。
- 只在 `done` 时更新状态,异常时界面一直转圈。
- 断线重试时重新提问,重复计费,且用户看到内容“跳回开头”。
- 组件卸载没有取消请求。
- 引用来源从模型的文本里正则解析,格式一变就失效。
- 流式过程中每个 token 都触发完整的 Markdown 解析和渲染,长回答卡顿。
## 面试怎么讲
> “AI 对话前端我做了一个组合式函数:用 fetch + ReadableStream 读 SSE,因为要 POST 和带鉴权头;自己写了增量解析器处理分块边界;状态机区分连接中、生成中、完成、失败、已停止;停止生成用 AbortController,组件卸载自动取消。断线时带 Last-Event-ID 重试,后端从缓存的事件继续发,不重新生成。引用来源通过 final 事件的结构化 JSON 返回,前端渲染成卡片。这些都有单元测试。”