高阶问题(AI 工程师)
前端与网络与大文件与性能优化 100 题
AI 工程师面试题库 · 第一批(题号 0–99):JavaScript 核心、TypeScript、Vue3、React 18/19、网络协议、大文件上传与传输、性能优化。
- 面试
- AI 工程师
- 前端
AI 工程师面试题库 · 第一批:前端、网络、大文件上传、性能优化
- 一、JavaScript 核心(0–19)
- 0. 事件循环(Event Loop)的完整模型是什么?
- 1. Promise 三态与链式调用的错误传播?
- 2. async/await 的本质与并发控制?
- 3. 闭包的实际用途与内存陷阱?
- 4. 原型链与 class 的关系?
- 5. 深拷贝的完整实现要考虑什么?
- 6. 防抖和节流的区别与场景?
- 7. 事件委托是什么,为什么列表常用?
- 8. let/const 暂时性死区(TDZ)?
- 9. 箭头函数与普通函数的五大差异?
- 10. 模块化:ESM 与 CJS 的核心差异?
- 11. 垃圾回收:什么情况内存无法回收?
- 12. 标签模板字符串有什么用?
- 13. Proxy 能拦什么,Reflect 为什么成对出现?
- 14. WeakMap/WeakSet 的弱引用语义?
- 15. 可选链
?.与空值合并??的组合拳? - 16. 迭代协议:for…of 与 for…in 的区别?
- 17. 生成器 Generator 在前端还有什么用?
- 18. requestAnimationFrame 与 setTimeout 做动画的区别?
- 19.
structuredClone与 JSON 序列化拷贝的边界?
- 二、TypeScript(20–29)
- 三、Vue3 核心(30–44)
- 30. Vue3 响应式:effect、track、trigger 三者关系?
- 31. computed 的缓存与链式依赖?
- 32. watch 的深度监听与多维监听?
- 33. watchEffect 的自动依赖与清理机制?
- 34. 组件通信全图:九种方式与选型?
- 35. provide/inject 的响应式与依赖注入设计?
- 36. Vue3 生命周期迁移对照与 Script Setup 的变化?
- 37. v-model 在组件上的完整机制(3.4 defineModel)?
- 38. slot 三类:默认/具名/作用域插槽的取舍?
- 39. keep-alive 的生命周期与 include 黑白名单?
- 40. 异步组件与 Suspense 的骨架屏方案?
- 41. Teleport 与弹窗层级治理?
- 42. 自定义指令 v-permission 的实现?
- 43. Pinia 的 store 组合式写法与跨 store 调用?
- 44. Vue 性能优化清单:v-memo、shallowRef、markRaw?
- 四、React 18/19(45–57)
- 45. JSX 与模板编译的本质差异?
- 46. Fiber 与可中断渲染?
- 47. Hook 规则为什么是”顶层调用、顺序一致”?
- 48. useEffect 完整心智模型:同步副作用与依赖数组?
- 49. useMemo/useCallback 的正确度量?
- 50. useRef 的两大用途与 state 的边界?
- 51. Context 的性能陷阱与拆分?
- 52. 状态管理选型:Zustand/Jotai/Redux Toolkit 的分界?
- 53. React 19:use hook 与 Actions?
- 54. React 错误边界与全局兜底?
- 55. 受控与非受控组件的选择?
- 56. React Portals 与 Vue Teleport 对应?
- 57. React 性能排查:从 Profiler 到优化手段?
- 五、网络协议(58–74)
- 58. 从 URL 到页面:DNS 解析的分层缓存?
- 59. TCP 三次握手/四次挥手,为什么是三次?
- 60. HTTPS/TLS 握手:非对称换对称?
- 61. HTTP 状态码面试常考清单?
- 62. 同源策略与 CORS 完整机制?
- 63. Cookie 属性全解:安全四件套?
- 64. HTTP/1.1 → 2 → 3 的演进主线?
- 65. WebSocket 握手与心跳保活?
- 66. SSE(Server-Sent Events)与 LLM 流式?
- 67. fetch 读取流:ReadableStream 解码分块?
- 68. 中断请求:AbortController 全场景?
- 69. JWT 结构与无状态认证的取舍?
- 70. 鉴权三件套对比:Session/Cookie、JWT、OAuth2/OIDC?
- 71. CDN 原理:就近回源与缓存命中?
- 72. 接口幂等与防重的前后端配合?
- 73. 限流算法:令牌桶/漏桶/滑动窗口?
- 74. WebSocket 集群扩散:多实例怎么把消息发给”任意在线用户”?
- 六、大文件上传与传输(75–87)
- 75. 大文件上传为什么必须分片?
- 76. 秒传:文件 hash 的计算与体验优化?
- 77. 断点续传:已传分片怎么跳过?
- 78. 服务端(Nest)如何接分片与合并?
- 79. 直传 OSS/MinIO:预签名 URL 方案?
- 80. 分片直传 MinIO 的合并替代:Multipart Upload?
- 81. 上传进度与并发控制:XHR 与 fetch 的差异?
- 82. 大文件下载:流式与断点续传(Range)?
- 83. 导出超大 Excel 的工程方案?
- 84. 前端下载二进制与文件名乱码?
- 85. 图片上传的前端处理:压缩与方向?
- 86. 粘性上传:弱网下的重试与退避策略?
- 87. 上传安全:类型校验与病毒墙?
- 七、性能优化(88–99)
- 88. 性能指标体系:Core Web Vitals 与采集?
- 89. LCP 优化:首屏最大元素为什么慢?
- 90. INP 优化:长任务拆分与调度?
- 91. CLS 优化:布局偏移的经典来源?
- 92. 包体积:bundle analyzer 驱动的减脂清单?
- 93. 渲染层优化:重排/重绘与合成层?
- 94. 虚拟列表完整实现思路?
- 95. Web Worker 实战:什么活该搬进去?
- 96. 首屏 SSR/SSG/ISR 的选型逻辑?
- 97. 资源提示词:preload/prefetch/modulepreload 实战?
- 98. 运行时性能:防泄漏的组件清理模式?
- 99. 性能预算与 CI 门禁?
一、JavaScript 核心(0–19)
本章各题指向同一底层事实:JS 只有一条线程,所有异步均为任务排队。理解事件循环模型后,多数时序问题可直接定位。
0. 事件循环(Event Loop)的完整模型是什么?
概念 JS 单线程执行:同步代码在调用栈运行,异步回调按优先级进入任务队列——微任务(Promise.then、queueMicrotask)优先级高于宏任务(setTimeout、I/O、事件)。异步回调按此优先级依次调度执行。
典型场景 Promise 里嵌 setTimeout 的输出顺序、Vue nextTick 的实现依据、Node 流处理时机——任何『为什么顺序和我想的不一样』的时序 bug。
解决方案 分四步递进:基础示例建立直觉 → 微任务嵌套的清空规则 → Node 环境差异 → 解释 nextTick 的实现依据。
第一步:基础示例——建立『先同步、后微任务、再宏任务』的执行顺序认知
// 文件: event-loop-basic.js
console.log('1 同步');
setTimeout(() => console.log('4 宏任务'), 0); // 0ms 也不会先跑
Promise.resolve().then(() => console.log('3 微任务'));
console.log('2 同步结束');
// 输出: 1 2 3 4 —— setTimeout 设 0 也排不赢微任务
为什么 setTimeout 设 0ms 仍非最先执行?其回调需等待下一轮循环,而微任务队列在本轮同步代码结束后立即执行完毕。
第二步:微任务嵌套——关键规则『清空清到没有』
// 文件: event-loop-nest.js
Promise.resolve().then(() => {
console.log('微任务 A');
Promise.resolve().then(() => console.log('微任务 A.1')); // 执行 A 时新产生的微任务
});
Promise.resolve().then(() => console.log('微任务 B'));
// 输出: A → B → A.1
很多人以为输出 A → A.1 → B——错。微任务队列是队列:A 先进先执行,执行中新产生的 A.1 追加到队尾,所以 B(已在队里)排在 A.1 前。记住『本轮清空清到没有,新来的排队尾』。
第三步:Node 环境的差异——nextTick 优先级与阶段模型
// 文件: event-loop-node.js
setTimeout(() => console.log('timeout'), 0);
setImmediate(() => console.log('immediate'));
Promise.resolve().then(() => console.log('promise'));
process.nextTick(() => console.log('nextTick'));
// 输出: nextTick → promise → timeout/immediate(主模块里两者顺序不定)
// nextTick 队列优先级最高; promise 是微任务其次; timeout/immediate 在宏任务阶段
// 但在 IO 回调里, setImmediate 恒先于 setTimeout —— 面试高频陷阱
第四步:回收到实战——为什么 Vue 的 nextTick 比 setTimeout 快?
DOM 更新是微任务级批处理:改十个数据只渲染一次,nextTick 排在本轮微任务里,比 setTimeout(下一轮宏任务)早一轮拿到新 DOM。这就是框架选微任务做批量更新的原因——离用户的下一次渲染最近。
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:为什么改数据后拿不到新 DOM? → 更新是异步批处理
- 追问2:nextTick 本质是什么? → 微任务(Promise.then),在渲染前执行
- 追问3:和 setTimeout 的区别? → 宏微任务时序——DOM 更新一定在 nextTick 之后、setTimeout 之前
- 防守要点:追问链是逐层深入的——第3层答稳了面试官才会问下一层;任何一层卡住,坦诚说清已知边界比硬编更得分。
总结:同步代码执行完毕 → 清空全部微任务(新增的排至队尾)→ 执行一个宏任务 → 再次清空微任务,循环往复;Node 环境额外存在 nextTick 高优先级队列与阶段模型。该模型可解释各类时序问题。
1. Promise 三态与链式调用的错误传播?
概念 Promise 具有三个状态:pending(进行中)、fulfilled(已成功)、rejected(已失败)。状态一旦变更不可回退。then 返回新 Promise,错误像水往低处流——沿链冒泡到最近的 catch。
典型场景 多步异步依赖(先查用户再查订单)、链中间 catch 影响范围的判断、『为什么我的 catch 接不住上一个 then』。
解决方案 四步走:先看链式怎么传值 → 再看错误怎么跳过中间 then → 看 catch 放中间和放尾部的差别 → 最后分析 async/await 中同一错误的处理方式。
第一步:链式传值——上一个 then 的返回值是下一个的输入
// 文件: promise-chain-basic.js
loadUser(1)
.then(user => loadOrders(user.id)) // 返回新 Promise, 下一步等它
.then(orders => orders.length) // 返回普通值, 直接传下去
.then(n => console.log('订单数:', n));
第二步:错误传播——reject 像电梯直达,中间 then 全部跳过
// 文件: promise-chain-skip.js
loadUser(-1)
.then(user => console.log('这行不会执行'))
.then(() => console.log('这行也不会'))
.catch(err => console.log('直达这里:', err.message));
第三步:catch 的位置决定影响范围——中间 catch 会『接住并复活』
// 文件: promise-catch-scope.js
loadUser(-1)
.catch(err => []) // 中间 catch: 吞掉错误, 返回恢复值
.then(orders => console.log('恢复了, 空列表渲染:', orders.length));
// 把中间 catch 删掉, 错误就会冲到链尾的兜底 catch —— 放哪里取决于你要不要局部降级
第四步:async/await 中的错误处理——try/catch 等价于链尾 catch
// 文件: promise-await-catch.js
async function main() {
try {
const user = await loadUser(-1); // await 把 reject 变成抛异常
console.log('不会执行');
} catch (err) {
console.log('try/catch 接住:', err.message); // 和 .catch 等价
}
}
追问预演(面试官顺着答案往深处问):
- 追问:catch 放中间和放尾部有什么区别? → 中间 catch 吞掉错误并返回恢复值使链继续;尾部 catch 只兜底
- 追问:then 里抛异常下游怎么感知? → 异常使该 then 返回的 Promise 进入 rejected,沿链冒泡
总结:链式传值是接力、错误传播是直达电梯、catch 位置决定降级层级、await 把这一切变成熟悉的 try/catch。四句话说完 Promise 错误处理。
2. async/await 的本质与并发控制?
概念 async/await 是 Promise 的语法糖:await 暂停的是当前函数,而非线程——控制权交回事件循环,其余代码继续执行。
典型场景 串行拉三个接口耗时 3s、循环里 await 一条条等、1000 个并发请求把服务端压垮。
解决方案 分三步递进:串行问题 → all/allSettled 并行方案 → 可限流的并发池实现。
第一步:串行陷阱——本可以同时等的三个请求排了队
// 文件: await-serial.js
// ❌ 三个互不依赖的请求串行等待, 总耗时 = a+b+c
const a = await fetchA();
const b = await fetchB();
const c = await fetchC();
第二步:并行——先发起,再一起等
// 文件: await-parallel.js
// ✅ 先全部发起(不等), 再统一 await —— 总耗时 = max(a,b,c)
const pa = fetchA(), pb = fetchB(), pc = fetchC(); // 注意: 这里没有 await
const [a, b, c] = await Promise.all([pa, pb, pc]);
// 全要成功用 all; 允许部分失败用 allSettled:
const results = await Promise.allSettled([pa, pb, pc]);
const ok = results.filter(r => r.status === 'fulfilled').map(r => r.value);
第三步:并发池——1000 个请求也不能真一起发
// 文件: concurrency-pool.js
async function pool(items, worker, limit = 5) {
const ret = []; let i = 0;
await Promise.all(Array.from({ length: limit }, async () => {
while (i < items.length) { const idx = i++; ret[idx] = await worker(items[idx]); }
}));
return ret;
}
const data = await pool(ids, fetchDetail, 5); // 最多 5 个同时在飞
limit 个 worker 从同一游标 i 领取任务——领取后执行,执行完毕继续领取。这就是手动实现的信号量机制。
追问预演(面试官顺着答案往深处问):
- 追问:1000 个请求全并发有什么问题? → 打垮服务端/触发限流,需并发池限流
- 追问:Promise.all 一个失败全失败怎么办? → 改用 allSettled,或给每个请求单独 catch 返回兜底值
总结:await 只是暂停函数不是阻塞线程;互不依赖的请求先发起后等待;量大必须限流——串行、并行、并发池,三档火力按场景选。
3. 闭包的实际用途与内存陷阱?
概念 闭包指函数与其词法作用域的组合:内部函数在其定义作用域之外执行时,仍可访问该作用域的变量。
典型场景 防抖节流实现、封装私有状态、循环里 setTimeout 打印错值(var 时代)、页面越用越卡(闭包泄漏)。
解决方案 分五步递进:基础闭包形态 → 泄漏成因与解救 → 柯里化实现 → 防抖节流实现 → React Hooks useState 的闭包本质。
第一步:基础闭包——函数捕获定义作用域的变量
// 文件: closure-basic.js
function makeCounter() {
let count = 0; // 闭包变量: 外部无法直接访问, 只能通过下面两个函数操作
return {
add() { count++; },
get() { return count; },
};
}
const c = makeCounter();
c.add(); c.add();
console.log(c.get()); // 2 —— makeCounter 已执行完毕, count 仍可访问
调用完 makeCounter(),其执行上下文已销毁,但 count 未被回收——返回的两个函数仍持有对它的引用。这就是闭包的核心机制。
第二步:闭包的泄漏与解救——引用未释放导致内存无法回收
// 文件: closure-leak.js
function startHeavyJob() {
const bigData = new Array(1024 * 1024).fill('x'); // 8MB 的闭包捕获变量
window.addEventListener('resize', () => {
console.log(bigData.length); // 监听器不删, bigData 永远无法回收
});
}
// ❌ 每调一次 startHeavyJob 就导致 8MB 内存无法回收
// ✅ 解救: 返回清理函数, 用完必调
function startHeavyJobSafe() {
const bigData = new Array(1024 * 1024).fill('x');
const onResize = () => console.log(bigData.length);
window.addEventListener('resize', onResize);
return () => window.removeEventListener('resize', onResize); // 清理函数
}
// const cleanup = startHeavyJobSafe(); cleanup(); —— 谁持有谁负责还
核心原则:闭包的生命周期决定了其捕获变量的内存占用时长。监听器、定时器、订阅均需提供清理接口。
第三步:柯里化——闭包的第一份正经工作
柯里化指将 f(a, b, c) 转换为 f(a)(b)(c) 的过程——每传入一个参数即返回一个『已捕获现有参数』的新函数,参数捕获依赖闭包实现。
// 文件: curry.js
function curry(fn) {
return function curried(...args) {
// 参数凑够了就执行原函数, 没凑够就返回一个『记住已传参数』的新函数
return args.length >= fn.length
? fn(...args)
: (...rest) => curried(...args, ...rest); // 闭包: args 被新函数持有
};
}
const log = curry((level, module, msg) => console.log(`[${level}][${module}] ${msg}`));
const errLog = log('ERROR'); // 持有 'ERROR' 的函数
const errUserLog = errLog('User'); // 持有 'ERROR'+'User'
errUserLog('登录失败'); // [ERROR][User] 登录失败
总结:柯里化的本质是利用闭包逐步收集参数,集齐后执行原函数。
第四步:防抖节流——闭包的日常主业
// 文件: debounce.js
function debounce(fn, delay = 300) {
let timer = null; // 闭包持有 timer: 每个防抖函数有自己独立的计时器
return function (...args) {
clearTimeout(timer);
timer = setTimeout(() => fn.apply(this, args), delay);
};
}
// 文件: throttle.js
function throttle(fn, interval = 200) {
let last = 0; // 闭包持有上次执行时间
return function (...args) {
const now = Date.now();
if (now - last >= interval) { last = now; fn.apply(this, args); }
};
}
// 组件里使用 + 卸载清理(第二步的铁律在这里落地)
// const onInput = debounce(search, 300);
// onUnmounted(() => onInput.cancel?.());
说明 timer/last 定义在闭包内的原因:若定义在函数内部,每次调用都会重置;闭包使这些变量跨调用存活——这是防抖节流能够成立的基础。
第五步:useState——React Hooks 的闭包本质
// 文件: mini-use-state.js
function makeHooks() {
const states = []; // 闭包数组: 按调用顺序存每个 state
let cursor = 0; // 闭包指针: 标记当前读到第几个
function useState(initial) {
const i = cursor++; // 本次是第几个 hook(顺序一致性的由来!)
if (states[i] === undefined) states[i] = initial;
return [states[i], (v) => { states[i] = v; render(); }]; // 闭包持有下标 i
}
function render() { cursor = 0; /* 重放所有 hook, 顺序不变才能对上号 */ }
return { useState, render };
}
分析:states 和 cursor 是 makeHooks 作用域内的变量,每个 useState 返回的 setter 通过闭包持有自己的下标——为什么 Hook 不能写进 if/循环?因为调用顺序一旦变化,下标与状态的对应关系即被打乱。至此,闭包原理可以直接推导出 Hook 的使用规则。
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:闭包一定内存泄漏吗? → 不是,只有持有了不再需要的大对象才算
- 追问2:V8 怎么优化闭包? → 隐藏类和逃逸分析,变量被内联后不进堆
- 追问3:React Hook 和闭包的关系? → 每次渲染是新的作用域,依赖数组决定用哪一帧的快照
- 防守要点:追问链是逐层深入的——第3层答稳了面试官才会问下一层;任何一层卡住,坦诚说清已知边界比硬编更得分。
总结:闭包使函数持有定义作用域的变量 → 引用未释放会导致泄漏,因此需要提供清理接口 → 逐步收集参数构成柯里化 → 持久化状态实现防抖节流 → 管理一组状态即 Hooks 的雏形。一条主线贯穿四个考点。
4. 原型链与 class 的关系?
概念 JS 底层没有类,只有原型链:对象有个 __proto__ 指针指向构造函数的 prototype,属性找不到就沿链上溯。class 是把这套机制包装成 Java 风格的语法糖。
典型场景 instanceof 的原理题、方法该挂哪一层、面试官问你『class 里定义的方法每个实例都有一份吗』。
解决方案 分四步递进:原型方式实现类 → class 等价重写 → 验证方法共享 → instanceof 与继承。
第一步:没有 class 的年代——原型继承怎么写
// 文件: prototype-old.js
function Animal(name) {
this.name = name; // 实例属性: 每个对象一份
}
Animal.prototype.speak = function () { // 共享方法: 挂原型, 所有实例同一份
return `${this.name} 叫`;
};
const a = new Animal('狗');
console.log(a.speak()); // 狗 叫
console.log(a.__proto__ === Animal.prototype); // true —— 链就在这
第二步:class 重写——与原型写法等价
// 文件: prototype-class.js
class Animal {
constructor(name) { this.name = name; } // 对应上面的构造函数
speak() { return `${this.name} 叫`; } // 自动挂到 Animal.prototype
}
const a = new Animal('猫');
console.log(a.speak());
console.log(typeof Animal); // 'function' —— class 本质还是函数
第三步:验证『共享』——方法在原型上只有一份
// 文件: prototype-share.js
const a1 = new Animal('A'), a2 = new Animal('B');
console.log(a1.speak === a2.speak); // true —— 同一个函数对象
// 而 a1.name !== a2.name —— 实例属性各自一份
// 所以: 频繁创建的对象, 方法挂原型(省内存); 仅属于个体的状态放实例
第四步:instanceof 与 extends——沿链查找的两个应用
// 文件: prototype-extends.js
class Dog extends Animal {
fetch() { return `${this.name} 捡球`; }
}
const d = new Dog('旺财');
console.log(d instanceof Dog); // true —— Dog.prototype 在链上
console.log(d instanceof Animal); // true —— Animal.prototype 也在链上(沿链找到)
console.log(d.__proto__ === Dog.prototype);
console.log(d.__proto__.__proto__ === Animal.prototype); // 链就这样一节节连起来
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:为什么不用 index 作 key? → 重排时状态错位
- 追问2:加了 :key 就够了吗? → 还要 key 稳定且唯一,用业务 id
- 追问3:key 变了会发生什么? → 旧节点销毁重建,组件生命周期重走
- 防守要点:追问链是逐层深入的——第3层答稳了面试官才会问下一层;任何一层卡住,坦诚说清已知边界比硬编更得分。
总结:原型链是 JS 继承的唯一机制,class 只是外壳;实例属性各自一份、原型方法全局共享;instanceof 就是『沿链能不能找到』。三句话带走这题。
5. 深拷贝的完整实现要考虑什么?
概念 赋值仅复制引用。浅拷贝(Object.assign/展开)只复制第一层,嵌套对象仍共享引用;深拷贝需递归复制所有层级,并处理循环引用及 Date/RegExp/Map/Set 等特殊类型。
典型场景 编辑表单复制草稿、状态回滚快照、修改副本导致原数据被改(常见生产事故)。
解决方案 分三步递进:浅拷贝的问题 → structuredClone 方案 → 手写递归实现(循环引用处理)。
第一步:浅拷贝问题复现场景分析
// 文件: clone-shallow.js
const original = { name: 'a', tags: ['x'] };
const copy = { ...original };
copy.tags.push('y');
console.log(original.tags); // ['x', 'y'] —— 原数据被改了!
// tags 是引用类型, 展开运算符只复制了引用
第二步:一招鲜——structuredClone 能覆盖 90% 场景
// 文件: clone-structured.js
const original = { name: 'a', tags: ['x'], at: new Date(), m: new Map([['k', 1]]) };
const copy = structuredClone(original);
copy.tags.push('y');
copy.m.set('k', 99);
console.log(original.tags, original.m.get('k')); // ['x'] 1 —— 互不干扰
// 注意边界: 函数、DOM 节点会抛出错误, 不复制原型
第三步:手写版——理解循环引用为什么要 WeakMap
// 文件: clone-deep.js
function deepClone(obj, cache = new WeakMap()) {
if (obj === null || typeof obj !== 'object') return obj;
if (cache.has(obj)) return cache.get(obj); // 循环引用: obj 引着自己, 不查缓存就无限递归
const clone = Array.isArray(obj) ? [] : {};
cache.set(obj, clone); // 先登记再递归 —— 顺序是关键
for (const [k, v] of Object.entries(obj)) clone[k] = deepClone(v, cache);
return clone;
}
const a = {}; a.self = a;
const b = deepClone(a);
console.log(b.self === b, b !== a); // true true —— 循环结构保留且独立
WeakMap 的键是弱引用,拷贝完成后缓存不阻碍 GC——这就是为什么不用普通 Map。
追问预演(面试官顺着答案往深处问):
- 追问:JSON 拷贝法什么时候够用? → 纯 JSON 数据(无 Date/Map/函数)且想顺带剥离 Proxy
- 追问:WeakMap 缓存为什么不会阻碍 GC? → 键为弱引用,不参与可达性计算
总结:浅拷贝只管一层、structuredClone 一招鲜、手写版的核心是『先登记再递归』防循环引用。场景选型:纯数据快照用内置,要自定义规则(剥离字段/转类型)才手写。
6. 防抖和节流的区别与场景?
概念 防抖是『等你彻底停下来再干』,节流是『再急也得按频率来』。防抖:停止触发 N 毫秒后才执行,期间重置计时;节流:N 毫秒内最多执行一次。
典型场景 搜索框输入联想(防抖)、scroll/resize 监听(节流)、按钮防连点(防抖)、LLM 输入框草稿自动保存(防抖)。
解决方案 分三步递进:防抖实现(timer 外置的原因) → 节流的时间戳实现 → 组件化封装与清理。
第一步:防抖——每次触发都推翻重来
// 文件: debounce.js
function debounce(fn, delay = 300) {
let timer = null; // 闭包持有 timer: 每个防抖函数有自己独立的计时器
return function (...args) {
clearTimeout(timer); // 关键: 先取消上一次的等待
timer = setTimeout(() => fn.apply(this, args), delay);
};
}
// 搜索框: 用户停手 300ms 才发请求, 输入 20 个字符只发 1 次
input.addEventListener('input', debounce(e => search(e.target.value), 300));
第二步:节流——掐表放行
// 文件: throttle.js
function throttle(fn, interval = 200) {
let last = 0; // 闭包持有上次执行时间
return function (...args) {
const now = Date.now();
if (now - last >= interval) { last = now; fn.apply(this, args); }
};
}
// scroll: 200ms 最多算一次进度, 滚再快也按频率来
window.addEventListener('scroll', throttle(updateBar, 200));
对比记忆:防抖的 timer 在外面因为要『跨调用重置』;节流的 last 在外面因为要『跨调用掐表』——都是闭包让状态跨调用存活(见 3)。
第三步:组件化封装——清理责任收进 hook
// 文件: debounce-hook.js
// Vue 版: 卸载时让挂起的调用作废, 防止组件已死回调还执行
export function useDebounce(fn, delay = 300) {
let timer = null;
const debounced = (...args) => {
clearTimeout(timer);
timer = setTimeout(fn, delay);
};
onUnmounted(() => clearTimeout(timer)); // 铁律(见 3 第二步)
return debounced;
}
追问预演(面试官顺着答案往深处问):
- 追问:防抖和节流能结合吗? → 可以,防抖后置节流(如搜索:停止输入 300ms 发请求,且最短 1s 一次)
- 追问:timer 为什么必须放闭包外? → 放函数内每次调用重置,无法跨调用保持状态
总结:防抖管『最后一次』,节流管『频率上限』;实现核心都是闭包存状态;进了组件必须配卸载清理。三句话,这题拿满。
7. 事件委托是什么,为什么列表常用?
概念 事件委托利用事件冒泡机制:子元素事件会传播至父级。将多个子元素的监听器收拢到父容器,通过 e.target + closest 定位实际目标。
典型场景 大规模表格逐元素绑定事件、动态渲染列表反复重绑、为后续动态创建的元素绑定事件。
解决方案 分三步递进:逐个绑定的问题 → 委托实现 → 边界处理(容器空白点击、子元素内部)。
第一步:逐个绑定的痛
// 文件: delegation-naive.js
// ❌ 1000 个 li = 1000 个监听器; 列表重渲染还要重新绑
document.querySelectorAll('.item').forEach(el =>
el.addEventListener('click', () => console.log(el.dataset.id)));
第二步:委托实现——单一监听器覆盖所有子元素
// 文件: delegation.js
document.getElementById('list').addEventListener('click', (e) => {
const item = e.target.closest('.item'); // 从实际点击处向上找最近的 .item
if (!item) return; // 点在容器空白处: 不是我们的目标
console.log('点击了', item.dataset.id);
});
// 动态新增的 li 无需重新绑定 —— 事件冒泡天然覆盖未来元素
第三步:两个边界——closest 的意义
// 文件: delegation-edge.js
// 边界 1: li 里有 <span>, e.target 是 span 不是 li —— closest('.item') 向上找到 li
// 边界 2: e.target 是容器本身(点空白) —— closest 返回 null, 直接 return
// 补充: 需要『阻止某子项触发』时, 在 closest 前判断 e.target.closest('.no-click')
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:Proxy 能代理数组吗? → 能,索引和 length 都是 set trap
- 追问2:那 Vue3 为什么还有 markRaw? → 性能——深度代理有开销,第三方实例(图表/地图)不该被追踪
- 追问3:shallowRef 和 markRaw 的区别? → 前者整组不追踪只看引用,后者单个对象永不代理
- 防守要点:追问链是逐层深入的——第3层答稳了面试官才会问下一层;任何一层卡住,坦诚说清已知边界比硬编更得分。
总结:委托 = 冒泡 + closest 认领;省监听器、天然支持动态元素。代价是每个点击都过一遍判断,所以超高频事件(mousemove)别用委托。
8. let/const 暂时性死区(TDZ)?
概念 TDZ(暂时性死区)指 let/const 声明的作用域起点至声明语句执行之间的区域,访问该变量抛 ReferenceError,即使外层存在同名变量。var 无此限制(声明提升、值为 undefined)。
典型场景 代码搬家后莫名 ReferenceError、typeof 一个未声明的 let 也报错(打破『typeof 永不报错』的直觉)、面试官问提升机制。
解决方案 分三步递进:var 的提升行为 → let 的 TDZ 现象 → 循环中 var/let 的差异(结合闭包)。
第一步:var——声明提升,值 undefined
// 文件: tdz-var.js
console.log(x); // undefined —— 声明提升了, 值还没赋
var x = 1;
第二步:let——保护期里碰就报错
// 文件: tdz-let.js
function demo() {
// console.log(y); // ReferenceError: 不能在声明前访问(即使外层有 y)
let y = 1;
console.log(y); // 1
}
let y = 0; demo();
// typeof 未声明的 let 变量也报错 —— TDZ 连 typeof 都不放过
第三步:循环里 var vs let——面试最经典的变体
// 文件: tdz-loop.js
for (var i = 0; i < 3; i++) setTimeout(() => console.log('var:', i));
// 输出 3 3 3 —— 一个共享的 i, 回调执行时循环早跑完了
for (let i = 0; i < 3; i++) setTimeout(() => console.log('let:', i));
// 输出 0 1 2 —— let 每轮迭代创建一个新的绑定(规范专门为循环定义的语义)
这题和闭包3是一对:var 时代要靠 IIFE 给每轮造独立作用域,let 直接解决了。
追问预演(面试官顺着答案往深处问):
- 追问:typeof 在 TDZ 里也报错吗? → 报错,let/const 的死区连 typeof 都不放过
- 追问:for 循环里 let 每轮新建绑定是规范行为吗? → 是,规范专门为 let 在迭代语义中定义了每轮创建新环境
总结:var 提升+可重复声明;let/const 有 TDZ 保护期;循环里 let 每轮新绑定。原则:默认 const,要重新赋值才 let,var 进博物馆。
9. 箭头函数与普通函数的五大差异?
概念 箭头函数没有自身的 this,其 this 取自词法作用域(外层函数)。同理不具备 arguments、prototype、new.target,因此不能通过 new 调用,不能作为 Generator。
典型场景 定时器/事件回调中 this 丢失、类方法作为回调时 this 为 undefined、箭头函数能否被 new 调用。
解决方案 分三步递进:this 丢失场景 → 箭头函数的解决方案 → 箭头函数的限制(两个反例)。
第一步:事故场景分析——普通函数的 this 是『谁调用归谁』
// 文件: arrow-this-lost.js
const timer = {
seconds: 0,
start() {
setInterval(function () {
this.seconds++; // ❌ this 是 undefined(strict)/window —— setInterval 调用它时没带主人
}, 1000);
},
};
第二步:箭头函数救场——外层的 this 被捕获
// 文件: arrow-this-fix.js
const timer = {
seconds: 0,
start() { // 普通函数: this = timer(谁调用归谁)
setInterval(() => { this.seconds++; }, 1000); // 箭头: 住 start 的 this, 也就是 timer
},
};
timer.start();
setTimeout(() => console.log(timer.seconds)); // 1 —— 动起来了
第三步:两个反例——箭头函数不能用的地方
// 文件: arrow-limit.js
// 反例 1: 对象方法 —— this 会指向更外层(通常是 window), 拿不到对象自己
const bad = { name: 'x', hello: () => console.log(this?.name) }; // undefined
// 反例 2: 构造器 —— 没有 [[Construct]] 内部方法, new 调用抛出 TypeError
// const P = () => {}; new P(); // TypeError: P is not a constructor
// 结论: 『需要 this 指向调用者』的场景(DOM 处理器/对象方法/构造器)用普通函数;
// 『需要外层 this』的回调场景用箭头。
追问预演(面试官顺着答案往深处问):
- 追问:箭头函数有 arguments 吗? → 没有,同样取外层(可用 rest 参数 …args 替代)
- 追问:对象字面量方法用箭头会怎样? → this 指向外层作用域而非对象本身,拿不到实例
总结:箭头函数没有自己的四件套(this/arguments/prototype/new.target);选型一句话——回调要外层 this 用箭头,方法要调用者 this 用普通函数。
10. 模块化:ESM 与 CJS 的核心差异?
概念 两套模块系统性格完全不同。CJS(CommonJS):运行时加载、值拷贝(require);ESM:编译期静态分析、值引用(import 活绑定)、可 tree-shaking。
典型场景 打包产物中 dead code 未被移除;ESM 包在 CJS 项目中报 require() of ES Module 错误;路由级按需加载。
解决方案 分三步递进:值拷贝与活绑定的差异 → 静态分析与 tree-shaking 的关系 → 动态 import 分包。
第一步:值拷贝 vs 活绑定——CJS 拿到快照,ESM 拿到直播
// 文件: esm-vs-cjs.js
// CJS: require 那一刻的值被拷贝, 之后源文件变化感知不到
// const c = require('./counter.cjs'); c.count → 0(即使内部后来 ++)
// ESM: import 是活的引用
import { count, inc } from './counter.js';
console.log(count); // 0
inc();
console.log(count); // 1 —— 同一个变量, 不是快照
第二步:静态分析——import 必须顶层的原因
// 文件: esm-static.js
import { a } from './mod.js'; // ✅ 编译期就能确定依赖图
// if (cond) { import ... } // ❌ 语法错误 —— 条件里不能写静态 import
// 这就是 tree-shaking 的前提: 打包器编译期扫出哪些导出没人用, 直接删
第三步:动态 import——要运行时就得走函数形态
// 文件: esm-dynamic.js
// 路由级代码分割: 点进页面才加载图表库
async function openReport() {
const { default: ECharts } = await import('echarts'); // 动态 import 返回 Promise, 自动分包
const chart = ECharts.init(document.getElementById('box'));
chart.setOption({ series: [{ type: 'bar', data: [1, 2, 3] }] });
}
追问预演(面试官顺着答案往深处问):
- 追问:tree-shaking 为什么对 CJS 无效? → require 是运行时动态取值,编译期无法确定哪些导出被使用
- 追问:动态 import 的使用场景? → 路由级分包、大依赖按需加载、条件加载
总结:CJS 快照、ESM 直播;静态分析成就 tree-shaking;运行时按需走 import()。选型:应用代码一律 ESM,库双格式发布。
11. 垃圾回收:什么情况内存无法回收?
概念 GC 采用可达性分析:从根对象(全局对象、当前调用栈)沿引用遍历,不可达对象即可回收。常见泄漏源:意外的全局变量、未清理的定时器/回调、脱离 DOM 的引用、闭包持有大对象(原理见 3 第二步)。
典型场景 SPA 长时间运行后性能下降;聊天页轮询导致 Detached DOM 堆积;内存占用持续上涨。
解决方案 分三步递进:构造可控泄漏 → DevTools 定位 → 组件化修复模式。
第一步:构造可控泄漏——三行代码使内存无法回收
// 文件: leak-make.js
const cache = []; // 全局数组是 GC 的『根』
function onClick() {
const huge = new Array(100000).fill(new Date());
cache.push({ el: document.getElementById('btn'), huge }); // 引用被根持有住 → 永不回收
}
// 每点一次 +1 份, 内存曲线阶梯上涨 —— 经典的 Detached DOM + 大对象双重泄漏
第二步:采集性能数据——Memory 快照对比
Chrome DevTools → Memory → 拍快照 → 操作 10 次 → 再拍快照 → 选 Comparison:
找 Delta 为正且 Count 持续增长的对象;
看 Retainers 链: 谁持有它(cache 数组) → 顺着找泄漏源头
第三步:修复模式——清理责任收进抽象层
// 文件: leak-fix.js
// 统一的副作用 hook: 绑定和清理强制成对
export function useInterval(fn, ms) {
const t = setInterval(fn, ms);
onUnmounted(() => clearInterval(t)); // Vue; React 版在 useEffect 的 cleanup 里 return clearInterval
}
// useInterval(refresh); —— 调用方没有清理义务, 泄漏风险由封装层规避
追问预演(面试官顺着答案往深处问):
- 追问:怎么发现内存泄漏? → DevTools Memory 快照对比,看 Delta 增长与 Retainers 引用链
- 追问:Detached DOM 是什么? → 已从文档移除但仍被 JS 引用的节点,无法回收
总结:GC 只回收『够不着根的』;四大泄漏源都本质是『被根持有住了』;抓泄漏用快照对比看 Retainers;修复靠成对清理的封装。
12. 标签模板字符串有什么用?
概念 标签模板指模板字符串紧跟一个函数:该函数接收(静态片段数组, 插值数组)两个参数。styled-components、SQL/HTML 防注入、国际化均基于此机制。
典型场景 组件库样式方案(styled-components)、HTML 拼接防 XSS、对插值统一处理(转义/翻译/加密)。
解决方案 分两步递进:标签模板的参数结构 → safeHtml 实战。
第一步:参数结构——观察标签模板传入的两份参数
// 文件: tagged-basic.js
function tag(strings, ...values) {
console.log(strings); // ['Hello ', ', you are ', '!'] —— 静态片段
console.log(values); // ['Tom', 18] —— 所有插值
return 'done';
}
tag`Hello ${'Tom'}, you are ${18}!`;
第二步:实战 safeHtml——插值统一转义防 XSS
// 文件: tagged-template.js
function safeHtml(strings, ...values) {
return strings.reduce((acc, s, i) => {
const v = values[i - 1];
const esc = String(v).replace(/[&<>"']/g, c => ({ '&': '&', '<': '<', '"': '"' }[c] ?? c));
return acc + esc + s; // 插值转义后再拼接, 防 XSS
});
}
const userInput = '<img src=x onerror=alert(1)>'; // 模拟用户输入(含恶意载荷)
document.body.innerHTML = safeHtml`<h1>${userInput}</h1>`; // 载荷被转义为纯文本, 不执行
追问预演(面试官顺着答案往深处问):
- 追问:标签模板和普通函数调用区别? → 参数形态不同:静态片段数组+插值数组,保留了原始结构
- 追问:styled-components 的原理? → 标签模板接收插值生成 CSS 类名与样式规则
总结:标签模板 = 把模板字符串交给函数加工;静态片段和插值分开送,所以能对插值做统一处理。一句话:styled-components 管样式,你的 safeHtml 管安全,机制相同。
13. Proxy 能拦什么,Reflect 为什么成对出现?
概念 Proxy 对目标对象设置拦截层,可拦截 13 种操作(get/set/deleteProperty/has/apply/construct 等)。Reflect 提供默认行为转发:trap 内执行默认逻辑时应使用 Reflect 并传递 receiver。
典型场景 Vue3 响应式原理、SDK 无侵入埋点、对象访问审计日志。
解决方案 分三步递进:最小代理 → Reflect 的必要性(receiver 问题) → 访问追踪器实战。
第一步:最小代理——get/set 拦截
// 文件: proxy-basic.js
const p = new Proxy({ a: 1 }, {
get(t, key) { console.log('读', key); return t[key]; },
set(t, key, v) { console.log('写', key, '=', v); t[key] = v; return true; },
});
p.a; // 读 a
p.a = 2; // 写 a = 2
第二步:Reflect——为什么不能直接 t[key]
// 文件: proxy-reflect.js
const obj = { get name() { return this.nickname; }, nickname: 'Tom' };
const bad = new Proxy(obj, { get(t, key) { return t[key]; } }); // ❌ this=t, getter 里 this.nickname 拿不到代理
const good = new Proxy(obj, { get(t, key, receiver) { return Reflect.get(t, key, receiver); } });
console.log(bad.name, good.name); // undefined 'Tom' —— receiver 决定 getter 里的 this 指向谁
第三步:实战——访问追踪器(埋点雏形)
// 文件: proxy-track.js
function track(obj, key) { console.log(`[dep] 登记 ${String(key)}`); } // 依赖收集(演示桩)
function trigger(obj, key) { console.log(`[dep] 派发 ${String(key)}`); } // 派发更新(演示桩)
function audit(obj) {
return new Proxy(obj, {
get(t, key, receiver) { console.log(`[audit] 读 ${String(key)}`); return Reflect.get(t, key, receiver); },
set(t, key, v, receiver) { console.log(`[audit] 写 ${String(key)}=${v}`); return Reflect.set(t, key, v, receiver); },
});
}
const user = audit({ name: 'Tom' });
user.name; user.name = 'Jerry'; // 每次读写都有日志, 业务代码零改动
追问预演(面试官顺着答案往深处问):
- 追问:Reflect 不传 receiver 会怎样? → 原型链上的 getter 其 this 指向目标而非代理,深层代理场景取值错误
- 追问:Proxy 能被 JSON.stringify 识别吗? → 能,序列化会触发 get trap(可借机做透明处理)
总结:Proxy 管拦截,Reflect 管『按原样转发』(必须带 receiver);Vue3 的 reactive 即在此基础上增加 get 中依赖收集、set 中派发更新的完整实现。
14. WeakMap/WeakSet 的弱引用语义?
概念 WeakMap 的键为弱引用,不参与 GC 可达性计算——当对象仅有 WeakMap 引用时即可被回收,对应条目自动移除。因此不可遍历、无 size 属性。
典型场景 为 DOM 元素挂载元数据(元素移除后缓存自动清理)、框架内部缓存组件实例、深拷贝的循环引用缓存(见 5)。
解决方案 分两步递进:Map 的泄漏场景 → WeakMap 方案。
第一步:Map 版泄漏场景分析
// 文件: weakmap-leak.js
const meta = new Map();
function bind(el, data) { meta.set(el, data); }
bind(document.querySelector('#box'), { big: new Array(1e6) });
document.querySelector('#box').remove();
// DOM 节点从页面删了, 但 meta 这个根还持有它 —— 节点+数据都无法回收
第二步:WeakMap 根治
// 文件: weakmap-fix.js
const meta = new WeakMap();
function bind(el, data) { meta.set(el, data); }
bind(document.querySelector('#box'), { big: new Array(1e6) });
document.querySelector('#box').remove();
// 页面引用一断, WeakMap 里的条目自动可回收 —— 无需手动 delete
// 代价: 不可遍历、无 size —— 与键对象生命周期绑定的缓存必然有这些限制
追问预演(面试官顺着答案往深处问):
- 追问:WeakMap 的键可以是基本类型吗? → 不可以,键必须为对象(弱引用只能作用于对象)
- 追问:为什么 WeakMap 不可遍历? → 条目随时可能被 GC 移除,遍历结果不可靠
总结:WeakMap/WeakSet 的条目生命周期与键对象绑定——键对象可回收时条目自动移除。选型:需要遍历/计数用 Map;仅用于挂载元数据或防循环缓存时用 Weak 版本。
15. 可选链 ?. 与空值合并 ?? 的组合拳?
概念 ?. 在 null/undefined 时短路返回 undefined;?? 仅在左侧为 null/undefined 时取右侧值——注意 0 和 ” 是有效值,不会被替换。
典型场景 深层数据访问 a.b.c 中途为 undefined 报错;默认值使用 || 导致 0 被替换;第三方接口响应结构不稳定。
解决方案 分三步递进:传统写法的嵌套判断 → ?./?? 组合 → 0 值陷阱对照。
第一步:老写法地狱
// 文件: nullish-old.js
function readCount(resp) {
let count;
if (resp && resp.data && resp.data.count !== undefined) count = resp.data.count;
else count = 0;
return count;
}
第二步:组合拳一行
// 文件: nullish-modern.js
function readCount(resp) {
return resp?.data?.count ?? 0; // 任一环节 null/undefined → 短路 → 取 0
}
function readName(form) {
return form.name?.trim() ?? '匿名';
}
第三步:0 值陷阱——|| 和 ?? 的分水岭
// 文件: nullish-zero.js
const v1 = 0 || 10; // 10 —— 0 被当 falsy 误伤
const v2 = 0 ?? 10; // 0 —— ?? 只认 null/undefined, 0 是合法值
// 场景: 数量 0、开关 false、空字符串 都是合法业务值 → 必须用 ??
// 场景: 数量 0、开关 false、空字符串 都是合法业务值 → 必须用 ??
追问预演(面试官顺着答案往深处问):
- 追问:?. 和 ?? 可以混用吗? → 可以,a?.b ?? c 是常见组合;注意 ?. 短路后 ?? 才生效
- 追问:|| 和 ?? 的选型原则? → 默认值语义为『仅无值时替换』用 ??;确需把 0/”/false 也当空值才用 ||
总结:?. 防断链,?? 防误伤;两者组合是现代 JS 读数据的标配。规则:涉及 0/”/false 的默认值,禁用 ||。
16. 迭代协议:for…of 与 for…in 的区别?
概念 for…of 遍历值(基于迭代器协议,查找 Symbol.iterator);for…in 遍历可枚举字符串键(含原型链)。
典型场景 遍历 Map/Set、对象误用 for…of 报错、自定义类实现迭代协议。
解决方案 分三步递进:两者行为对照 → 对象不支持 for…of 的原因 → 自定义类实现迭代器。
第一步:行为对照
// 文件: iteration-basic.js
const arr = ['a', 'b'];
for (const v of arr) console.log(v); // a b —— 值
for (const k in arr) console.log(k); // 0 1 —— 索引(键), 还包括后续挂在数组上的自定义属性
第二步:对象为什么不能 of
// 文件: iteration-object.js
const obj = { x: 1, y: 2 };
// for (const v of obj) {} // TypeError: obj is not iterable —— 没有 Symbol.iterator
for (const [k, v] of Object.entries(obj)) console.log(k, v); // ✅ 正确姿势
第三步:让自定义类可迭代
// 文件: iteration-custom.js
class Range {
constructor(a, b) { this.a = a; this.b = b; }
*[Symbol.iterator]() { // 实现迭代器协议(生成器最省事)
for (let i = this.a; i <= this.b; i++) yield i;
}
}
for (const n of new Range(1, 3)) console.log(n); // 1 2 3
追问预演(面试官顺着答案往深处问):
- 追问:for…in 会遍历原型链吗? → 会,通常配 hasOwnProperty 或 Object.keys 规避
- 追问:break 在 for…of 中生效吗? → 生效,迭代器会调用 return() 完成清理
总结:of 遍历值走协议,in 遍历键连原型;对象用 entries;自定义类实现 [Symbol.iterator] 即可被 of——迭代协议是 JS 统一的『可遍历』接口。
17. 生成器 Generator 在前端还有什么用?
概念 function* 定义生成器函数:执行至 yield 暂停并产出值,下次调用从暂停处继续。返回对象同时实现迭代器协议。
典型场景 大数据分页惰性生成、轮询状态机、redux-saga 式异步编排、自定义可迭代类(见 16 第三步)。
解决方案 分三步递进:暂停与恢复 → 惰性序列 → 生成器分页实战。
第一步:暂停与恢复
// 文件: generator-basic.js
function* counter() {
console.log('start');
yield 1; // 停在这, 把 1 交出去
console.log('resumed');
yield 2;
}
const it = counter();
console.log(it.next().value); // start → 1
console.log(it.next().value); // resumed → 2
第二步:惰性序列——要多少生成多少
// 文件: generator-lazy.js
function* fibonacci() {
let [a, b] = [0, 1];
while (true) { yield a; [a, b] = [b, a + b]; } // 无限序列也不怕: 不取不算
}
const fib = fibonacci();
console.log([fib.next().value, fib.next().value, fib.next().value]); // 0 1 1
第三步:实战——分页参数生成器
// 文件: generator-page.js
function* pageSequence(total, size = 20) {
for (let p = 0; p * size < total; p++) yield { page: p, size };
}
const pages = pageSequence(100);
console.log([...pages].slice(0, 2)); // 惰性: 只按需展开前两页的参数
追问预演(面试官顺着答案往深处问):
- 追问:生成器和普通函数内存差异? → 生成器保留执行上下文,长期不 complete 会持续占用,注意及时终止
- 追问:yield 是什么?* → 委托给另一个可迭代对象,透传产出
总结:生成器=可暂停函数;惰性求值是它最大的工程价值;异步编排(saga)是它的历史舞台。前端直接用它最多的场景:自定义迭代和惰性数据流。
18. requestAnimationFrame 与 setTimeout 做动画的区别?
概念 requestAnimationFrame(rAF)在浏览器下次重绘前回调,与屏幕刷新率天然同步;setTimeout 与渲染周期无关,高频率触发时可能造成丢帧。
典型场景 进度条动画掉帧、Canvas 逐帧渲染、LLM 打字机效果的高频更新卡顿。
解决方案 分三步递进:setTimeout 动画的丢帧问题 → rAF 实现 → rAF 与缓冲结合的打字机方案。
第一步:setTimeout 动画的问题——和渲染不同步
// 文件: raf-timeout.js
// 场景同上(方块右移到 300px)。❌ 16ms 定时器和浏览器渲染(60fps≈16.7ms)错拍, 长跑必丢帧
function stepTimeout() {
x += 2;
box.style.transform = `translateX(${x}px)`;
if (x < 300) setTimeout(stepTimeout, 16); // 与刷新周期不同步, 可能一帧内跑两次或跳帧
}
stepTimeout();
第二步:rAF 版——跟着渲染节奏走
// 文件: raf-basic.js
// 场景: 方块从左到右匀速移动, 到 300px 停止
const box = document.getElementById('box');
let x = 0;
function step() {
x += 2; // 每帧右移 2px
box.style.transform = `translateX(${x}px)`; // transform 不触发重排(见 93)
if (x < 300) requestAnimationFrame(step); // 未到终点, 预约下一帧
}
requestAnimationFrame(step); // 启动第一帧
// 附赠: 页面切后台时 rAF 自动暂停 —— 不消耗资源, 回到前台继续
第三步:实战——LLM 打字机的每帧合并
// 文件: raf-typewriter.js
const buf = []; // SSE 到达的 token 先进缓冲
let scheduled = false;
function appendToken(t) {
buf.push(t);
if (!scheduled) {
scheduled = true;
requestAnimationFrame(() => { // 每帧最多渲染一次
el.textContent += buf.join('');
buf.length = 0;
scheduled = false;
});
}
}
// 一帧内到达的 20 个 token 合并成 1 次 DOM 更新 —— 60fps 下每秒最多 60 次渲染
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:白屏 3 秒先查什么? → Network 看 TTFB 和资源瀑布
- 追问2:JS 太大怎么办? → 分包+按需+分析器
- 追问3:还慢呢? → 看 LCP 元素是不是图片/CSS 阻塞,上 preload
- 防守要点:追问链是逐层深入的——第3层答稳了面试官才会问下一层;任何一层卡住,坦诚说清已知边界比硬编更得分。
总结:动画跟 rAF,不跟 setTimeout;rAF 与刷新率同步+后台自动暂停;高频数据流(SSE/输入)一律『缓冲+每帧刷一次』。
19. structuredClone 与 JSON 序列化拷贝的边界?
概念 JSON 序列化拷贝存在局限:丢失 undefined/函数/Symbol、Date 转为字符串、不支持循环引用;structuredClone 支持 Date/Map/Set/循环引用,但不支持函数与 DOM 节点、不复制原型。
典型场景 表单草稿快照、API 请求前剥离响应式代理(JSON 序列化天然剥离 Proxy)、含 Date/Map 的数据拷贝。
解决方案 分三步递进:JSON 拷贝的局限 → structuredClone 方案 → 选型决策。
第一步:JSON 法暗坑实测
// 文件: clone-json-pitfalls.js
const src = { at: new Date(), fn: () => {}, undef: undefined, m: new Map([['k', 1]]) };
const dst = JSON.parse(JSON.stringify(src));
console.log(dst.at); // '2026-...' 字符串, 不是 Date
console.log(dst.fn, dst.undef); // undefined undefined —— 直接丢了
console.log(dst.m); // {} —— Map 变空对象
第二步:structuredClone 接管
// 文件: clone-choice.js
const raw = JSON.parse(JSON.stringify(toRaw(formState))); // 剥 Vue 响应式代理后发请求(纯 JSON 场景 JSON 法反而合适)
const snap = structuredClone(raw); // 含 Date/Map 的快照用内置, 支持循环引用
第三步:选型决策表
纯 JSON 数据(无 Date/Map/函数) → JSON 法(顺带剥代理)
含 Date/Map/Set/循环引用 → structuredClone
含函数/类实例/需要自定义规则 → 手写递归(见 5 第三步)
追问预演(面试官顺着答案往深处问):
- 追问:structuredClone 能拷函数吗? → 不能,直接报错;JSON 法会静默丢弃,注意场景选择
- 追问:Vue 里 toRaw 和 JSON 法剥离 Proxy 的区别? → toRaw 只剥一层代理不改数据;JSON 法深拷贝且丢类型
总结:JSON 法是『只认 JSON 的搬运工』,structuredClone 是『认全类型的搬运工』但拒收函数;按数据形态选择方案。
二、TypeScript(20–29)
TypeScript 面试区分度较高:仅记忆语法者难以回答 satisfies 与 unknown 的差异,而有泛型工具实战经验者可深入展开。本章选取具有区分度的考点。
20. interface 与 type 的区别与选择?
概念 分工原则——interface 描述对象/函数形状且支持同名声明合并;type 支持类型运算。具体:interface 可声明合并(同名自动合并)、只描述对象/函数形状;type 支持联合、交叉、条件、映射、元组等全部类型运算。扩展:interface extends,type 交叉 &(属性冲突时 type 报错,interface 合并后可能出 never 字段)。
典型场景 公共 API 类型(可能被声明合并补充)用 interface;工具类型、联合类型必须 type。
解决方案 团队二选一统一,常见约定:对象形状 interface,类型运算 type。
// 文件: interface-vs-type.ts
interface User { id: number; name: string }
interface User { age: number } // 声明合并: User 有三个字段
type Status = 'active' | 'banned'; // 联合只能 type
type Nullable<T> = T | null; // 工具类型只能 type
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:同名 interface 和 type 撞了会怎样? → interface 同名合并;type 同名直接报重复定义错
- 追问2:extends 交叉属性冲突谁报错? → interface 合并后冲突字段类型若不兼容成 never;type 交叉立即标红
- 追问3:第三方库补类型用哪个? → interface——声明合并正是为扩展设计的
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:interface 管对象形状与声明合并,type 管类型运算;冲突时 type 报错更早,公共 API 可被合并扩展选 interface。一句话:能合并的用 interface,要运算的用 type。
21. 泛型约束 extends 与默认类型?
概念 泛型约束通过 extends 限定类型参数的形状(T extends { id: number }),在函数体内可用约束成员;默认类型 T = string 在未指定时兜底。
典型场景 通用请求函数要求返回结构、pick 函数限定 key 属于对象。
解决方案 约束+infer 组合实现类型安全的通用工具。
// 文件: generic-constraint.ts
function pick<T, K extends keyof T>(obj: T, keys: K[]): Pick<T, K> {
const ret = {} as Pick<T, K>;
keys.forEach(k => (ret[k] = obj[k]));
return ret;
}
const u = pick({ id: 1, name: 'a', age: 2 }, ['id', 'name']); // 类型是 { id, name }
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:
keyof T约束解决了什么? → 把 key 参数限制在真实键集合内,拼错编译期就报 - 追问2:约束和默认类型能同时用吗? → 能,
T extends X = Y,默认类型必须满足约束 - 追问3:泛型在运行时还存在吗? → 不存在,编译期擦除——运行时校验要靠 zod/IO 校验
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:extends 限定形状、默认类型兜底,两者组合让通用函数既灵活又在编译期锁死误用。泛型是编译期契约,运行时还得靠校验。
22. 工具类型 Partial/Required/Pick/Omit/Record 的实现原理?
概念 这些工具类型均基于映射类型实现:[K in keyof T] 遍历键,加 ?/-? 修饰可选性。Partial=全可选,Pick=只取 K,Omit=先 Exclude 再 Pick,Record=键集到值的映射。
典型场景 API 返回子集类型、表单编辑态(全字段可选)、枚举到值的字典。
解决方案 能手写才算掌握。
// 文件: my-utility-types.ts
type MyPartial<T> = { [K in keyof T]?: T[K] };
type MyPick<T, K extends keyof T> = { [K2 in K]: T[K2] };
type MyOmit<T, K extends keyof T> = MyPick<T, Exclude<keyof T, K>>;
type MyRecord<K extends keyof any, V> = { [P in K]: V };
type FormEdit = MyPartial<User>; // 所有字段可选
type UserBrief = MyOmit<User, 'password'>;
const roles: MyRecord<'admin' | 'user', string[]> = { admin: ['a'], user: [] };
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:Partial 加
?后能撤销吗? → 能,映射修饰符-?(Required 的实现) - 追问2:Omit 为什么不直接映射? → 先 Exclude 缩键集再 Pick,避免 keyof T 展开炸类型
- 追问3:readonly 怎么加? → 映射时加
readonly前缀,同理-readonly可去 - 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:五大工具类型全是映射类型+键集运算的组合:in 遍历、?/-? 调可选、Exclude 缩集。能手写 Partial/Pick/Omit 即算过关。
23. 条件类型与 infer 提取?
概念 条件类型 T extends U ? X : Y 是类型级分支;infer 在 extends 子句中声明待推断的类型变量。原定义: 在 extends 子句中”声明一个待推断的槽位”,提取嵌套类型的成分。
典型场景 解包 Promise、提取数组元素、函数返回值类型、路由路径抽参数。
解决方案 记住经典模式:UnwrapPromised、ElementType、ReturnType。
// 文件: conditional-infer.ts
type Unwrap<T> = T extends Promise<infer V> ? Unwrap<V> : T; // 递归解包
type Elem<T> = T extends (infer E)[] ? E : never;
type PathParams<S extends string> =
S extends `${string}:${infer P}/${infer Rest}`
? P | PathParams<`/${Rest}`>
: S extends `${string}:${infer P}` ? P : never;
type A = Unwrap<Promise<Promise<number>>>; // number
type B = PathParams<'/user/:id/post/:postId'>; // 'id' | 'postId'
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:条件类型何时触发分配? → 裸类型参数被联合类型代入时逐成员分配(distributive)
- 追问2:怎么禁止分配? → 用
[T] extends [U]包一层元组 - 追问3:infer 可以同时推断多个吗? → 可以,如
[F, ...R]解构,常用于递归类型 - 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:条件类型是类型级 if,infer 是待推断槽位;裸参数遇联合自动分配,不想分配加元组括号。递归+infer 可实现 Unwrap/PathParams 等深度工具。
24. satisfies 与类型注解的差异?
概念 : T 注解会将字面量类型拓宽为 T;satisfies 校验结构但保留字面量推断。对照:: T 注解拓宽丢字面量信息;satisfies T 校验符合 T 但保留字面量推断。
典型场景 路由表/主题表——既想校验结构,又想 routes.user.path 的 key 保持精确类型。
解决方案 配置表一律 satisfies。
// 文件: satisfies.ts
type Routes = Record<string, { path: string; auth: boolean }>;
const routes = {
user: { path: '/user/:id', auth: true },
home: { path: '/', auth: false },
} satisfies Routes;
type RouteKey = keyof typeof routes; // 'user' | 'home'(注解写法会退化成 string)
routes.user.path;
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:as const 和 satisfies 能一起用吗? → 能,
satisfies T校验结构,as const锁定字面量,常组合在配置表上 - 追问2:注解拓宽规则是什么? → 字面量赋给注解变量时 widened 成基类型(string/number)
- 追问3:satisfies 失败时报错友好吗? → 定位到具体字段,比 as 断言静默吞错安全得多
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:: T 校验但拓宽丢精度,satisfies 校验且保留字面量推断。路由/主题/枚举配置表一律 satisfies——校验和精确类型兼得。
25. unknown 与 any 的区别?为什么尽量 unknown?
概念 any 跳过类型检查;unknown 为安全顶类型,使用前必须收窄。定义:any 关闭类型检查(可赋给/接受一切);unknown 是安全顶类型——只能赋给 unknown/any,使用前必须收窄。
典型场景 第三方无类型的返回值、JSON.parse、try/catch 的 err(默认 unknown)。
解决方案 边界处 unknown + 收窄(typeof/in/类型守卫),把不安全限制在最小的检查层。
// 文件: unknown-narrow.ts
interface User { id: number; name: string }
function parse(input: string): User {
const data: unknown = JSON.parse(input);
if (typeof data === 'object' && data !== null && 'id' in data && 'name' in data) {
return data as User; // 收窄后才允许断言
}
throw new Error('invalid user payload');
}
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:unknown 能直接算术运算吗? → 不能,必须先收窄(typeof/instanceof/断言)
- 追问2:JSON.parse 返回什么类型? → any——边界数据应显式标 unknown 再收窄
- 追问3:never 和 unknown 的关系? → never 是空集(所有类型的子类型),unknown 是全集(所有类型的父类型)
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:any 放弃检查并污染下游,unknown 强制先收窄后使用。外部输入(API/JSON.parse/localStorage)标 unknown,把不确定性关进类型系统的笼子。
26. 类型守卫 is 与断言 as 的边界?
概念 is 守卫是编译器认可的收窄依据;as 为强制断言,不做校验。定义:守卫函数 x is T 使编译器识别收窄;as 是强行断言(不校验,错了运行时才炸)。
典型场景 数组 filter 后类型不变(filter 不自动收窄)、复用复杂的判断逻辑。
解决方案 复杂判断抽守卫函数;as 只用于”确实比编译器多知道信息”的边界。
// 文件: type-guard.ts
interface Admin { role: 'admin'; perms: string[] }
interface Member { role: 'member' }
type Person = Admin | Member;
function isAdmin(p: Person): p is Admin { return p.role === 'admin'; }
const list: Person[] = [];
const admins = list.filter(isAdmin); // admins: Admin[](用布尔函数则仍是 Person[])
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:is 守卫函数里撒谎会怎样? → 编译器全信你,运行时错到天涯海角——守卫体必须真校验
- 追问2:as 双重断言什么时候出现? →
as unknown as T,通常是类型设计错了的信号 - 追问3:satisfies 能替代 as 吗? → 方向不同:as 是”我说是”,satisfies 是”你检查它是不是”
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:is 让谓词函数参与类型收窄,as 是一次性强制改型。能用 is 守卫就不写 as;as 断言越少,类型系统越可信。
27. 枚举 enum 与 const 枚举/字面量联合的取舍?
概念 三种写法三种命运:enum 生成真对象(可反向映射)、const enum 编译期内联(旧行为,很多配置已弃用)、字面量联合 'a'|'b' 零运行时(最贴近 JS,tree-shaking 友好)。
典型场景 状态字段取值集合;需要”值 → 名”反查时 enum 才有优势。
解决方案 默认字面量联合 + as const 对象;确需反查用 enum。
// 文件: enum-choice.ts
type OrderStatus = 'pending' | 'paid' | 'shipped'; // 首选: 零运行时
const STATUS_LABEL = { // 语义标注
pending: '待支付', paid: '已支付', shipped: '已发货',
} as const satisfies Record<OrderStatus, string>;
const enum Direction { Up, Down } // 仅在确需反向映射时用普通 enum
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:enum 的运行时产物是什么? → 双向映射对象(字符串枚举单向);const enum 内联但与 isolatedModules 冲突
- 追问2:enum 值能是计算值吗? → 数字枚举可以(依赖前面的值),字符串枚举必须字面量
- 追问3:为什么很多团队弃用 enum? → 产物多余、const enum 兼容坑,字面量联合 + as const 足够
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:enum 有真实运行时对象,字面量联合零产物且天然可收窄。新代码优先 'a' | 'b' + as const 对象;enum 仅在需要命名空间/反向映射时考虑。
28. 声明文件 .d.ts 什么时候写、怎么写?
概念 .d.ts 仅包含类型声明不含实现,用于给无类型的 JS 库补类型、声明全局变量(window 上的注入)、模块声明。
典型场景 import x from '老库' 报没有类型定义;window.APP_CONFIG 自定义全局。
解决方案 declare module 补模块类型;declare global 扩 window。
// 文件: types/shims.d.ts
declare module 'legacy-widget' {
export function init(el: HTMLElement, opts?: { theme?: string }): void;
}
declare global {
interface Window {
APP_CONFIG?: { apiBase: string };
}
}
export {};
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:declare 和普通导出的区别? → declare 只声明不实现,编译后消失,用于描述已有运行时
- 追问2:三方库没有类型怎么办? → 先找 @types/xxx;没有则写模块级
.d.ts补最小面 - 追问3:全局类型放哪? →
declare global+export {}把文件变成模块,防全局污染 - 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:.d.ts 描述”已有的运行时”而非新逻辑:三方库补声明、window 挂载、环境变量。写最小面,别把实现搬进声明文件。
29. 泛型工具:Awaited 与返回类型的分层推断?
概念 别重复写类型——函数返回 Promise<T>,拿 T 直接要 Awaited<ReturnType<typeof fn>>(TS 内置 Awaited 递归解包)。
典型场景 接口层定义了函数,其他模块想要”数据本身的类型”而不重复声明。
解决方案 type Data = Awaited<ReturnType<typeof fetchList>>;——类型跟着实现走,单一事实源。
// 文件: infer-return.ts
async function fetchList(): Promise<{ items: { id: number }[]; total: number }> {
return { items: [{ id: 1 }], total: 1 };
}
type ListData = Awaited<ReturnType<typeof fetchList>>; // 不写第二遍结构
const total: ListData['total'] = 1;
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:Awaited 和自己的 Unwrap 差在哪? → Awaited 还处理 thenable 联合与递归边界,更完备
- 追问2:函数重载的返回类型怎么取? → ReturnType 取最后一个重载签名
- 追问3:怎么取函数参数类型? → Parameters
[number] - 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:类型分层推断=顺着数据流取型:async 函数返回 Promise
三、Vue3 核心(30–44)
本章主线是响应式系统:effect 收集依赖、trigger 派发更新。各 API 考点均可回溯至该机制,理解主线后答题深度显著提升。
30. Vue3 响应式:effect、track、trigger 三者关系?
概念 effect 指依赖变化时会重新执行的函数(组件渲染本质是一个 effect);执行时读响应式属性触发 track(把当前 effect 记入该属性的依赖集合,结构 targetMap: WeakMap<target, Map<key, Set
典型场景 解释”为什么改了数据视图就更新”;排查依赖丢失(解构、条件分支)。
解决方案 理解”读时收集、写时触发”;依赖是动态的——每次运行重新收集,不运行就不依赖。
// 文件: mini-reactive.js (极简示意)
let activeEffect = null;
const depsMap = new Map();
function track(key) {
if (!activeEffect) return;
if (!depsMap.has(key)) depsMap.set(key, new Set());
depsMap.get(key).add(activeEffect); // 读: 收集当前 effect
}
function trigger(key) {
(depsMap.get(key) ?? []).forEach(fn => fn()); // 写: 重跑依赖
}
function effect(fn) { (activeEffect = fn), fn(), (activeEffect = null); }
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:track 什么时候被触发? → 组件渲染/effect 执行中读到 proxy 属性时,收集当前 activeEffect
- 追问2:为什么需要 Reflect.get 的第三参? → 让 getter 里的 this 指向 proxy,继承属性也能被正确 track
- 追问3:数组 push 为什么会 track 多次? → length 和索引都被读,Vue 内部有去重(同 key 同 effect 只记一次)
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:effect 运行→读属性触发 track(建属性→effect 映射)→写属性触发 trigger(通知映射里的 effect 重跑)。响应式系统本质是”读时登记、写时广播”。
31. computed 的缓存与链式依赖?
概念 computed 采用 dirty 标记实现缓存——它是特殊的 effect:依赖变化只置 dirty 不立即重算,读取时若 dirty 才重算并缓存。computed 也可被其他 computed/watch 依赖,形成依赖图。
典型场景 列表过滤排序(依赖 list+keyword)、由价格和数量算总价、多处渲染同一派生值。
解决方案 派生数据一律 computed;副作用(发请求)绝不放 computed。
// 文件: computed-chain.js
const total = computed(() => price.value * count.value);
const formatted = computed(() => `¥${total.value.toFixed(2)}`); // 依赖 computed 的 computed
// keyword 变化时 filtered 只在下次读取时重算一次
const filtered = computed(() => list.value.filter(i => i.name.includes(keyword.value)));
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:computed 里的依赖变化但值没变,下游会更新吗? → 不会,computed 有值相等检查(dirty 机制)
- 追问2:computed 里写异步/副作用行吗? → 不行,computed 应是纯函数,副作用放 watchEffect
- 追问3:computed 返回 ref 吗? → 返回只读 ref;写计算属性(带 getter/setter)可用于 v-model 封装
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:computed 是带缓存的派生值:依赖变了先标脏,真正被读时才重算;值不变不传播。派生数据用 computed,别在里头藏副作用。
32. watch 的深度监听与多维监听?
概念 watch 为显式声明监听源的方案。签名:watch(source, cb, opts),source 可以是 ref/reactive 对象(隐式深监听)/getter 函数/数组(多源)。getter 只监听返回值,要监听内部变化加 { deep: true }。
典型场景 同时监听页码和关键词重置列表;监听表单对象任意字段变化。
解决方案 多源数组 + [a, b] 解构新值;reactive 对象默认深;精确监听某字段用 getter。
// 文件: watch-multi.js
watch([() => query.page, () => query.keyword], ([p, k], [op, ok]) => {
if (p !== op) fetchList();
if (k !== ok) { query.page = 1; fetchList(); }
}, { immediate: true });
watch(() => form.address.city, (c) => saveDraft(c)); // saveDraft 为草稿保存函数; 只盯嵌套的一个字段
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:deep 监听大对象有什么代价? → 递归遍历所有嵌套属性,层级深/字段多时开销显著
- 追问2:监听 reactive 对象的某个属性怎么写? → getter 函数
() => obj.key,隐式 deep 才会整棵遍历 - 追问3:watch 数组源的多个依赖算一次还是多次? → 批处理:同一 tick 多源变化合并回调一次
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:watch 显式声明监听源:单 ref 传 ref、对象属性传 getter、多源传数组;deep 换来的全量遍历在大对象上是真实开销。精确声明监听源优于无脑 deep。
33. watchEffect 的自动依赖与清理机制?
概念 watchEffect 为自动收集依赖的方案:执行一次,运行中读取的响应式值全部成为依赖。行为:立即执行一次,返回停止函数;回调接收 onCleanup 用于清理上一次未完成的副作用(如取消请求)。
典型场景 搜索词变化自动请求(旧请求要作废);依赖”当前在用什么”比”监听什么”更自然的场景。
解决方案 竞态用 onCleanup 里 AbortController.abort。
// 文件: watch-effect-race.js
watchEffect(async (onCleanup) => {
const ctrl = new AbortController();
onCleanup(() => ctrl.abort()); // keyword 再变, 上一个请求作废
const res = await fetch(`/api/search?q=${keyword.value}`, { signal: ctrl.signal });
results.value = await res.json();
});
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:watchEffect 和 watch 怎么选? → 依赖在回调里自然读到的用 watchEffect;需要旧值/只跑一次的用 watch
- 追问2:onCleanup 解决什么? → 竞态——新一次执行前取消上一次的请求/定时器
- 追问3:watchEffect 会不会跑在组件挂载前? → 会,默认立即同步执行一次,DOM 操作要放 onMounted 或用 flush:‘post’
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:watchEffect 自动追踪回调内读到的响应式依赖,立即执行、自动清理(onCleanup 防竞态)。写起来省心,代价是依赖关系不如 watch 显式。
34. 组件通信全图:九种方式与选型?
概念 组件通信方式包括:props/emit(父子)、v-model(双向)、ref+defineExpose(父调子实例)、provide/inject(跨层)、attrs(透传)、slot(内容分发)、mitt 事件总线(任意)、Pinia(全局)、路由参数(页面间)。
典型场景 任何组件拆分的第一问——“数据放哪、谁来改”。
解决方案 就近原则——父子 props/emit;深层注入用 provide/inject(传 ref 保响应式);跨页面/全局共享 Pinia;事件总线只做”通知”不做”数据流”。
<!-- 文件: components/ThemeUser.vue -->
<script setup lang="ts">
import { inject, ref } from 'vue';
import { useThemeStore } from '@/stores/theme';
const theme = useThemeStore(); // 全局: Pinia
const theme2 = inject('theme', ref('light')); // 跨层: inject, 传 ref 保响应式
const emit = defineEmits<{ change: [val: string] }>();
</script>
<template>
<button :style="{ color: theme.color }" @click="emit('change', theme2.value)">换色</button>
</template>
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:props 单向数据流怎么理解? → 子组件不能改 props,要改就 emit 事件让父组件改,数据源唯一
- 追问2:跨层级 deep child 改祖辈数据? → provide/inject(readonly 包装)或状态库,事件链层层 emit 是反模式
- 追问3:expose 是干嘛的? → script setup 默认封闭,defineExpose 选择性暴露实例成员给父组件 ref
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:父子 props/emit、跨层 provide/inject、全局 Pinia、实例 ref/expose——九种方式按”关系远近+数据性质”选型,默认走最短路径。
35. provide/inject 的响应式与依赖注入设计?
概念 注意:provide 普通对象时,子组件修改不会触发更新——值须为 ref/computed 才具备响应性。规则:provide 的值若为 ref/computed,inject 拿到的就是响应式引用;直接 provide 普通对象,修改不会触发更新。模式:提供方”单一数据源+方法”,消费方只读。
典型场景 主题、当前用户、表格组件向深层单元格下发状态;组件库开发(表单组件向 FormItem 下发校验方法)。
解决方案 provide(‘key’, { data: readonly(x), doSomething }),消费方禁改源。
// 文件: use-user.ts (提供方封装成 hook)
const USER_KEY = Symbol('user');
export function provideUser() {
const user = ref<User | null>(null);
provide(USER_KEY, { user: readonly(user), setUser: (u: User) => (user.value = u) });
}
export function useUser() {
const ctx = inject(USER_KEY);
if (!ctx) throw new Error('useUser 必须在 provideUser 之后使用');
return ctx;
}
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:inject 的默认值怎么给? →
inject(key, defaultValue),不设默认且未提供时是 undefined 并告警 - 追问2:为什么 provide 要 readonly? → 防止任何后代绕过提供方直接改数据,保持单一数据源
- 追问3:provide 的值不响应式会怎样? → 后代拿到的是死值,提供方更新后代不更新——必须 provide ref/reactive
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:provide 传 ref/reactive 才有响应式;Symbol 作 key 防冲突,readonly 包装防篡改。它解决的是”跨层级但不跨应用”的依赖传递。
36. Vue3 生命周期迁移对照与 Script Setup 的变化?
概念 迁移对照:beforeCreate/created 阶段的初始化写在 setup 顶层。对照:beforeCreate/created → setup 本身;beforeDestroy/destroyed → beforeUnmount/unmounted;组合式 API 全部 on 前缀(onMounted…)。script setup 里组件无需注册,顶层 import 即用。
典型场景 Vue2 项目迁移;初始化请求放哪(创建期 vs 挂载期)。
解决方案 与 DOM 无关的初始化(注入、store)放 setup 顶层;DOM 操作/第三方实例放 onMounted;清理放 onUnmounted。
<!-- 文件: ChartPanel.vue -->
<script setup lang="ts">
import { onMounted, onUnmounted, ref } from 'vue';
import * as echarts from 'echarts';
const props = defineProps<{ options: echarts.EChartsCoreOption }>();
const el = ref<HTMLElement>();
let chart: echarts.ECharts | null = null;
onMounted(() => { chart = echarts.init(el.value!); chart.setOption(props.options); });
onUnmounted(() => chart?.dispose()); // 不 dispose 就是内存泄漏
</script>
<template><div ref="el" style="height: 300px" /></template>
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:script setup 里还需要 data/methods 吗? → 不需要,顶层变量即 data、顶层函数即 methods,默认全部暴露给模板
- 追问2:beforeDestroy 改成什么了? → beforeUnmount;destroyed → unmounted
- 追问3:setup 里怎么拿路由/仓库? → 组合式 API(useRouter/useStore),替代 this 上下文
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:选项式→组合式的迁移核心是”this 消失”:生命周期改名(Unmount)、逻辑按功能聚合而非按选项分类。script setup 是默认推荐写法。
37. v-model 在组件上的完整机制(3.4 defineModel)?
概念 组件上的 v-model 就是块糖:支持参数 v-model:title 多绑定、修饰符 modelModifiers(如 .trim)。3.4 起 defineModel 宏仅需一行声明。
典型场景 表单组件封装(输入框、选择器、日期);弹窗开关双向绑定。
解决方案 直接 defineModel,支持默认值和 get/set 转换。
<!-- 文件: BaseInput.vue -->
<script setup lang="ts">
const model = defineModel<string>({ default: '', set: v => v.trim() }); // 3.4+
// 等价旧写法: props.modelValue + emit('update:modelValue')
</script>
<template>
<input :value="model" @input="model = ($event.target as HTMLInputElement).value" />
</template>
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:3.4 之前 v-model 在组件上等价于什么? → modelValue prop + update:modelValue 事件,defineModel 是这套的语法糖
- 追问2:一个组件能写多个 v-model 吗? → 能,
v-model:title对应 defineModel(‘title’) - 追问3:defineModel 返回值能直接改吗? → 能,内部替你 emit,父组件不传时还能本地兜底(局部状态)
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:组件 v-model = prop + emit 的标准化封装;3.4 的 defineModel 把样板代码压成一行,还支持修饰符与本地兜底。表单类组件首选。
38. slot 三类:默认/具名/作用域插槽的取舍?
概念 slot 用于内容分发;作用域插槽进一步将子组件内部数据交给父组件的渲染函数——渲染结构由父组件定义,数据由子组件提供——数据是子组件的,DOM 结构是父组件的。
典型场景 通用卡片(头/内容/尾)、表格列模板(列渲染逻辑外部定义、行数据内部循环)、AI 聊天里”消息气泡渲染权交给外部”。
解决方案 结构固定传 props 就够;渲染结构需要外部定制才上 slot;数据在子、样式在父,用作用域插槽。
<!-- 文件: MessageList.vue (子) -->
<script setup lang="ts">
defineProps<{ messages: { id: number; role: string; content: string }[] }>();
</script>
<template>
<div v-for="m in messages" :key="m.id">
<slot :msg="m" :isMe="m.role === 'user'">
{{ m.content }} <!-- 默认插槽内容 -->
</slot>
</div>
</template>
<!-- 文件: ChatPage.vue (父) -->
<MessageList :messages="msgs">
<template #default="{ msg, isMe }">
<Bubble :right="isMe" :html="DOMPurify.sanitize(renderMarkdown(msg.content))" /> <!-- renderMarkdown 为项目内 Markdown→HTML 函数; 模型/他人输入, 必须消毒 -->
</template>
</MessageList>
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:作用域插槽解决什么问题? → 子组件有数据、父组件定渲染——数据在子作用域,模板想在父作用域写
- 追问2:具名插槽缩写怎么写? →
#name="scope",等价 v-slot:name - 追问3:slot 内容更新会触发子组件重渲染吗? → 插槽内容归父组件作用域,父数据变才重渲染该部分
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:默认插槽塞内容、具名插槽多点投放、作用域插槽反向传数据。组件库的列表/表格渲染定制全靠作用域插槽。
39. keep-alive 的生命周期与 include 黑白名单?
概念 keep-alive 缓存组件实例,切换时不销毁;激活/失活钩子 onActivated/onDeactivated 代替 mounted/unmounted;include/exclude 按组件名过滤,max 限制缓存数量(LRU)。
典型场景 Tab 页切换保留表单状态、列表页跳详情返回不丢滚动位置和筛选条件。
解决方案 路由层 keep-alive 包 router-view + include 动态名单;页面激活时刷新数据(onActivated 里拉最新)。
<!-- 文件: Layout.vue -->
<template>
<router-view v-slot="{ Component }">
<keep-alive :include="cachedViews" :max="10">
<component :is="Component" />
</keep-alive>
</router-view>
</template>
<script setup lang="ts">
const cachedViews = ['OrderList', 'ChatPage']; // 与组件 name 匹配
</script>
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:include 怎么匹配? → 组件 name(或 script setup 自动推导的文件名),支持逗号串/正则/数组
- 追问2:keep-alive 里路由页怎么精确失效? → 配合路由 meta 与 include 动态数组,离开时从列表移除
- 追问3:max 是干嘛的? → LRU 上限,超出裁掉最久未用的实例,防内存无限涨
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:keep-alive 缓存组件实例,activated/deactivated 替代部分 mount/unmount 逻辑;include/exclude 控制范围,max 控制内存。缓存是把双刃剑——脏数据回显要主动处理。
40. 异步组件与 Suspense 的骨架屏方案?
概念 defineAsyncComponent 按需加载组件(自动代码分割);Suspense 处理 async setup 组件的加载/错误态(fallback/ default / onErrorCaptured)。
典型场景 首屏图表/编辑器太重要分包;整页 async 数据加载统一 loading。
解决方案 路由级用路由懒加载;组件级重包用异步组件;Suspense 注意其子树任一 async 出错要 onErrorCaptured 兜底。
// 文件: load-heavy.ts
import { defineAsyncComponent } from 'vue';
import Spinner from './Spinner.vue'; // 加载占位组件
import LoadError from './LoadError.vue'; // 失败兜底组件
const HeavyEditor = defineAsyncComponent({
loader: () => import('./HeavyEditor.vue'),
delay: 200, // 200ms 内返回则不显示 loading
loadingComponent: Spinner,
errorComponent: LoadError,
timeout: 15000,
});
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:defineAsyncComponent 的 loading/error 组件怎么配? → loader 旁配 loadingComponent/errorComponent/delay/timeout
- 追问2:Suspense 和 defineAsyncComponent 冲突吗? → 各管一层:Suspense 处理 async setup,异步组件管动态 import,可组合
- 追问3:Suspense 为什么还是实验性的? → 边界行为(嵌套/回退时机)仍在调整,生产慎用
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:路由组件全用 defineAsyncComponent/动态 import 做代码分割;骨架屏=loadingComponent 或 Suspense fallback。按需加载是首屏优化的第一刀。
41. Teleport 与弹窗层级治理?
概念 Teleport 将子树渲染到指定 DOM 节点(to=“body”),组件逻辑仍保留在本组件内,组件逻辑仍在本组件内。解决弹窗嵌套在 overflow:hidden/z-index 上下文里被裁剪的问题。
典型场景 弹窗、全屏 loading、通知;嵌套滚动容器内的浮层。
解决方案 弹窗组件一律 Teleport to body + 统一 z-index 管理。
<!-- 文件: BaseDialog.vue -->
<template>
<Teleport to="body">
<div v-if="open" class="dialog-mask">
<div class="dialog"><slot /></div>
</div>
</Teleport>
</template>
<script setup lang="ts">defineProps<{ open: boolean }>();</script>
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:Teleport 的 to 能动态改吗? → 能挂到动态选择器,但目标必须在挂载时已存在
- 追问2:弹窗层级怎么治理? → 统一 z-index 令牌(CSS 变量分层:dropdown<drawer<modal<toast),不用魔法数字
- 追问3:Teleport 内容的事件冒泡到哪? → 逻辑上仍是组件树(事件给 Vue 组件链),DOM 位置在别处——React Portal 同理
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:Teleport 把 DOM 渲染到组件树外(to=“body”),解决 overflow 裁剪与层级上下文污染;逻辑归属不变。层级治理配统一 z-index 令牌。
42. 自定义指令 v-permission 的实现?
概念 指令钩子(mounted/updated/unmounted)拿到 DOM,做无 React 侵入的 DOM 级控制。按钮权限常用指令;权限变更响应式用 updated 钩子重判。
典型场景 按钮级权限(无权限移除/禁用)、复制文本 v-copy、防抖点击 v-debounce、输入自动聚焦 v-focus。
解决方案 权限码从 store 读,无权限移除元素(隐藏仍可被改 DOM 触发,严控用移除);安全兜底永远在后端。
// 文件: directives/permission.ts
import { useUserStore } from '@/stores/user';
export const vPermission = {
// 注意: perms 为异步加载时, mounted 时机可能早于权限到位 ——
// 严格场景应在权限就绪后再渲染(路由守卫等待), 或用 updated 钩子重判
mounted(el: HTMLElement, binding: { value: string }) {
const { perms } = useUserStore();
if (!perms.includes(binding.value)) el.parentNode?.removeChild(el);
},
};
// 使用: <button v-permission="'order:export'">导出</button>
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:指令钩子和生命周期什么关系? → created/mounted/updated/unmounted 对应元素各阶段,updated 里做重复逻辑要防抖
- 追问2:权限变更时已渲染的元素怎么办? → 指令只管挂载时判定,动态权限用组件级 v-if + 权限 store
- 追问3:getInstance 在 SSR 下注意什么? → SSR 无真实 DOM,涉及 DOM 的钩子直接跳过
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:自定义指令把”对 DOM 的横切操作”收敛成声明:v-permission 无权移除元素、v-focus 聚焦。注意指令是挂载时一次性判定,动态权限用响应式方案。
43. Pinia 的 store 组合式写法与跨 store 调用?
概念 defineStore 两种写法:options(state/getters/actions)与 setup 函数式(ref=computed=函数)。store 之间直接 import 调用,天然组合。
典型场景 用户 store 被权限 store 依赖;购物车 store 调商品 store 取价格。
解决方案 setup 写法类型推导最好;跨 store 在 action 里直接调用其方法。
// 文件: stores/cart.ts
export const useCartStore = defineStore('cart', () => {
const items = ref<CartItem[]>([]);
const total = computed(() => items.value.reduce((s, i) => s + i.price * i.qty, 0));
async function add(id: number) {
const product = await useProductStore().findById(id); // 跨 store
items.value.push({ ...product, qty: 1 });
}
return { items, total, add };
});
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:setup store 和 option store 怎么选? → 组合式写法与组件一致、能用组合函数,新代码统一 setup 风格
- 追问2:跨 store 调用会循环依赖吗? → 在函数体内调用另一个 store(用时取),不要在顶层互相引用
- 追问3:storeToRefs 为什么必须用? → 直接解构 store 会丢响应式,storeToRefs 把 state/getter 转成 ref
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:Pinia 用 defineStore 划领域,setup 写法最顺;跨 store 在 action 内互调;组件里解构必走 storeToRefs。持久化/重置用插件,不手写。
44. Vue 性能优化清单:v-memo、shallowRef、markRaw?
概念 v-memo 缓存 vnode(依赖数组不变跳过 diff);shallowRef 只对 .value 赋值触发(大列表内部变更不追踪);markRaw 标记永不做响应式(图表实例、第三方类)。
典型场景 万行大列表;ECharts/地图实例被 reactive 包裹后性能暴跌或报错。
解决方案 大数据列表分页/虚拟滚动 + shallowRef;第三方实例 markRaw;大组件局部 v-memo。
// 文件: perf-large-list.ts
const rows = shallowRef<Row[]>([]); // 整组替换才触发
async function load() { rows.value = await fetchRows(); }
function updateRow(id: number, patch: Partial<Row>) {
rows.value = rows.value.map(r => (r.id === id ? { ...r, ...patch } : r));
}
const chart = markRaw(echarts.init(el)); // 防止深度代理
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:v-memo 什么时候值得用? → 大列表中少数依赖不变的项,省 diff;普通组件加它是负优化
- 追问2:shallowRef 和 ref 的取舍? → 大数据结构整体替换用 shallowRef,只追踪 .value 引用,省深度代理开销
- 追问3:markRaw 用在哪? → 第三方实例(图表/map 实例)不该被代理,包 markRaw 防性能黑洞
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:Vue 性能三件套:v-memo 跳过无谓 diff、shallowRef 浅追踪大数据、markRaw 免代理外部实例。默认不用,热点再用。
四、React 18/19(45–57)
React 面试重点考察设计动机:为什么引入 Fiber、为什么 Hook 必须顺序调用、为什么不自动收集依赖。本章逐一拆解各 API 背后的设计原因。
45. JSX 与模板编译的本质差异?
概念 一个是表达式一个是 DSL:JSX 是真 JS(编译成 createElement/jsx 调用),完全图灵完备、运行时能力更强;Vue 模板是受限 DSL,编译期做静态提升/补丁标记等优化,运行时更省。
典型场景 技术选型对比;React 里写复杂条件渲染。
解决方案 React 条件渲染用 &&、三目、提前 return;列表 map + key。
// 文件: List.tsx
import React from 'react';
interface Item { id: number; name: string }
export function List({ items, empty }: { items: Item[]; empty: React.ReactNode }) {
if (!items.length) return <>{empty}</>; // 提前 return 代替嵌套三目
return <ul>{items.map(i => <li key={i.id}>{i.name}</li>)}</ul>;
}
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:JSX 是必须的吗? → 不是,它编译为 React.createElement/jsx() 调用,纯 JS 也能写组件
- 追问2:Vue 的模板和 JSX 各输出了什么? → Vue 模板编译成优化过的 render 函数(带 PatchFlag 静态标记);JSX 每次全量生成 vdom
- 追问3:静态提升是模板独有的优势吗? → 是,编译时信息让 Vue 能做静态提升/树摇,JSX 运行时才知道结构
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:JSX=运行时全量 vdom、灵活性高;模板=编译期可分析、优化空间大。两者是”灵活性 vs 编译时优化”的取舍,不是高下之分。
46. Fiber 与可中断渲染?
概念 React 16 前的渲染为同步递归过程,不可中断;Fiber 架构(React 16+)将渲染拆分为链表节点(Fiber)形式的工作单元,具备可中断、可恢复、可放弃特性。渲染分为两阶段:render 阶段(可中断,计算变更)与 commit 阶段(同步提交 DOM)。
典型场景 大列表输入框卡顿(输入优先级应高于列表更新);为什么 useTransition 能不卡。
解决方案 并发特性(useTransition/useDeferredValue)把低优更新让路。
// 文件: SearchTransition.tsx
const [input, setInput] = useState('');
const [keyword, setKeyword] = useState('');
const [isPending, startTransition] = useTransition(); // 返回的是数组, 必须解构
function onChange(e: React.ChangeEvent<HTMLInputElement>) {
setInput(e.target.value); // 高优: 输入框即时
startTransition(() => setKeyword(e.target.value)); // 低优: 列表可中断
}
// <input value={input} onChange={onChange} /> {isPending ? '加载中' : <BigList k={keyword} />}
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:Fiber 为什么能中断? → 渲染拆成链表节点单元,每完成一个单元可让出主线程检查更高优先级任务
- 追问2:哪些阶段不能中断? → commit 阶段(DOM 变更+生命周期)同步执行,防界面撕裂
- 追问3:lane 模型是什么? → 二进制优先级位图,比旧的 expirationTime 更细粒度地表达优先级与批处理
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:Fiber 把渲染切片化:render 阶段可中断可恢复(工作单元链表),commit 阶段同步提交。这是并发特性(useTransition/DeferredValue)的地基。
47. Hook 规则为什么是”顶层调用、顺序一致”?
概念 这不是规定,是机制——Hook 靠调用顺序对应状态(链表),条件/循环里调用会让顺序错位,状态串到别的 hook 上。
典型场景 初学者把 useState 放 if 里,切换条件后状态错乱报错。
解决方案 hook 只在组件顶层;条件逻辑放 hook 内部(effect 里 if)或拆组件。
// 文件: hook-rules.tsx
import { useState, useEffect } from 'react';
// getUser 为项目内 API 函数
function Profile({ id }: { id: number }) {
const [user, setUser] = useState<User | null>(null);
useEffect(() => { getUser(id).then(setUser); }, [id]); // 依赖变化重跑, 而不是条件调用 hook
// ❌ if (id) { useEffect(...) } —— 禁止
}
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:Hook 存在哪? → 函数组件 Fiber 节点的 memoizedState 链表,按调用顺序索引
- 追问2:条件调用报什么错? → 渲染间 Hook 数量不一致,React 直接抛错中断渲染
- 追问3:自定义 Hook 有独立的存储吗? → 没有,它只是复用 Hook 调用的函数,状态仍归调用它的组件
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:Hook 规则是机制不是约定——状态按调用顺序挂在 Fiber 链表上,顺序错位=状态错乱。所以只在顶层调用,条件逻辑放进 Hook 内部。
48. useEffect 完整心智模型:同步副作用与依赖数组?
概念 effect 在提交到 DOM 之后异步执行;依赖数组声明”哪些变化需要重跑”;空数组=仅挂载后。与事件回调的边界:响应用户操作放事件,响应状态变化放 effect。
典型场景 fetch 数据、订阅 websocket、操作非受控 DOM。
解决方案 每个 effect 一个职责;依赖里诚实写全(否则闭包旧值);竞态用 cleanup + AbortController。
// 文件: use-search.ts
function useSearch(q: string) {
const [data, setData] = useState<Item[]>([]);
useEffect(() => {
const ctrl = new AbortController();
fetch(`/api/search?q=${q}`, { signal: ctrl.signal })
.then(r => r.json())
.then(setData)
.catch(e => { if (e.name !== 'AbortError') throw e; });
return () => ctrl.abort(); // 下一次 q 之前取消上一次
}, [q]);
return data;
}
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:effect 里读了 state 但没写依赖,会发生什么? → 闭包旧值——每次渲染的 effect 捕获当次快照,依赖不全就读到过期数据
- 追问2:怎么只挂载时跑一次但读最新值? → ref 镜像最新值,或函数式更新 setState(s => …)
- 追问3:useLayoutEffect 和 useEffect 的时机差? → Layout 在 DOM 变更后浏览器绘制前同步执行(防闪烁);Effect 在绘制后
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:effect=提交后执行+依赖数组声明重跑+cleanup 清理竞态。依赖写全是诚实原则,竞态用 AbortController,DOM 测量才用 useLayoutEffect。
49. useMemo/useCallback 的正确度量?
概念 这俩是缓存,但缓存不免费:useMemo 缓存计算结果、useCallback 缓存函数引用;都有比较成本与内存成本。子组件 memo + 稳定 props 才有意义;context value 不稳定会让所有消费者重渲染。
典型场景 昂贵计算(排序几千条)、context 提供方、传递给 memo 子组件的回调。
解决方案 默认不包,profile 显示热点再包;context value 用 useMemo 组合。
// 文件: memo-rules.tsx
const ExpensiveList = memo(function ExpensiveList({ items, onPick }: Props) { /*...*/ });
function Parent({ id, bigList }: { id: number; bigList: Item[] }) {
const sorted = useMemo(() => [...bigList].toSorted(cmp), [bigList]); // 昂贵计算才 memo
const onPick = useCallback((x: Item) => pick(id, x), [id]); // 引用稳定传 memo 子组件
return <ExpensiveList items={sorted} onPick={onPick} />;
}
// pick/cmp 为模块内既有函数(按业务实现)
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:所有 props 都 useCallback 一遍行吗? → 比较成本+内存+代码噪音,子组件没用 memo 时纯属浪费
- 追问2:怎么判断该不该 memo? → Profiler 录制:子组件因此重渲染且渲染确实贵,才值得
- 追问3:依赖数组里的对象每次都是新引用怎么办? → 上游 useMemo 稳定,或依赖拆成原始值字段
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:useMemo/useCallback 是有成本的缓存,默认不包;Profiler 找到热点再包。memo 化子组件+稳定引用才是完整闭环,缺一不可。
50. useRef 的两大用途与 state 的边界?
概念 useRef 用于跨渲染存储可变值:存跨渲染可变、变更不触发渲染的值:DOM 引用、定时器 id、最新值镜像。需要”改了要重渲染”就用 state。
典型场景 打字机缓冲区(高频更新不想要渲染风暴)、保存 interval id 供卸载清理、获取前一帧值。
解决方案 高频写 + 低频渲染 = ref 缓冲 + rAF 批量刷新。
// 文件: use-stream-buffer.ts
function useStreamBuffer() {
const buf = useRef<string[]>([]);
const [, force] = useReducer((x: number) => x + 1, 0);
const scheduled = useRef(false);
function push(t: string) {
buf.current.push(t);
if (!scheduled.current) {
scheduled.current = true;
requestAnimationFrame(() => { force(); scheduled.current = false; }); // 每帧刷一次
}
}
return { push, text: () => buf.current.join('') };
}
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:ref.current 变化会触发渲染吗? → 不会——这正是它适合存定时器 id/高频缓冲的原因
- 追问2:渲染期间能读写 ref 吗? → 不能,渲染必须纯;读写放事件回调或 effect 里
- 追问3:forwardRef 是干嘛的? → 函数组件默认不透传 ref,forwardRef(或 19 直接 ref prop)把 ref 转给内部 DOM
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:ref=跨渲染可变容器不触发渲染(DOM 引用/定时器/最新值镜像);state=变更即渲染。高频写低频读用 ref 缓冲,渲染期间不碰 ref.current。
51. Context 的性能陷阱与拆分?
概念 Context 的性能问题:value 一旦变化,所有消费组件均重渲染(与是否使用了变化的字段无关)。大对象 context = 全员陪跑。
典型场景 全局 Theme/User context 包大对象;一个字段变化整棵树重渲染。
解决方案 按读写频率拆 context(State 拆 / Dispatch 拆);value 用 useMemo;高频数据换状态库订阅(selector)。
// 文件: split-context.tsx
import { createContext, useState } from 'react';
interface User { id: number; name: string }
const UserCtx = createContext<User | null>(null);
const SetUserCtx = createContext<(u: User) => void>(() => {});
function UserProvider({ children }: { children: React.ReactNode }) {
const [user, setUser] = useState<User | null>(null);
return (
<SetUserCtx.Provider value={setUser}> {/* setter 永不变化 */}
<UserCtx.Provider value={user}>{children}</UserCtx.Provider>
</SetUserCtx.Provider>
);
}
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:怎么让 context 不放大范围重渲染? → 拆 context(状态按消费方切分)、value useMemo、 children 提出Provider 外
- 追问2:state 放 context 还是 zustand? → 高频变更的全局状态用外部 store(订阅粒度细);低频配置型数据 context 足够
- 追问3:useContextSelector 解决什么? → 只订阅 context 里用到的切片,变更时仅相关消费者更新
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:Context 是依赖注入不是状态管理:value 一变全员重渲染。解法三板斧:拆分 context、稳定 value、高频状态移出 context 用外部 store。
52. 状态管理选型:Zustand/Jotai/Redux Toolkit 的分界?
概念 选型原则:服务端数据使用 TanStack Query 管理;客户端状态按团队需求选择。Zustand——轻量 store + selector 订阅(默认精确更新);Jotai——原子化状态,依赖图自动;RTK——重规范、DevTools 强、适合大团队约定。React Query/TanStack Query 管服务端状态(与客户端状态分离是现代共识)。
典型场景 新项目选型;服务端数据(列表、详情)在手写 useEffect+setState 时请求重发、缓存全无。
解决方案 服务端状态交给 TanStack Query(缓存/重试/失效一揽子),客户端状态(主题、草稿)用 Zustand。
// 文件: use-posts.ts (TanStack Query)
import { useQuery } from '@tanstack/react-query';
// api 为项目内请求封装
export function usePosts(page: number) {
return useQuery({
queryKey: ['posts', page],
queryFn: () => api.getPosts(page),
staleTime: 60_000, // 1 分钟内不重发
});
}
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:Zustand 为什么不会”全员重渲染”? → 组件按 selector 订阅切片,只有选中切片变化才重渲染
- 追问2:Jotai 的原子和 Zustand 的 store 差别? → atom 粒度到字段级、依赖图自动组合;store 是领域级整块
- 追问3:RTK 比 Redux 裸写好在哪? → createSlice 免样板、Immer 允许可变写法、内置 devtools/中间件
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:选型按变更粒度和团队习惯:组件局部 useState,跨组件切片订阅 Zustand/Jotai,大团队强规范+时间旅行 RTK。没有银弹,只有匹配。
53. React 19:use hook 与 Actions?
概念 use(promise/context)可在组件内条件调用,配合 Suspense 读异步数据;Actions(useActionState/useFormStatus)把表单提交的 pending/错误/乐观更新标准化;ref 直接作为 prop(去 forwardRef)。
典型场景 表单提交要 pending 态和错误展示(以前手写 loading state 三件套);父组件要把 ref 传给自定义输入。
解决方案 表单用 useActionState 接 action 函数;子组件 function Input({ ref, ...rest }) 直接透传。
// 文件: login-action.tsx
import { useActionState } from 'react';
interface State { user: unknown; error: string | null }
// login 为项目内认证函数
function action(prev: State, formData: FormData): Promise<State> {
return login(formData.get('username') as string, formData.get('password') as string)
.then(user => ({ user, error: null }))
.catch(e => ({ user: null, error: e.message }));
}
function LoginPage() {
const [state, submit, pending] = useActionState(action, { user: null, error: null });
return (
<form action={submit}>
<input name="username" /><input name="password" type="password" />
<button disabled={pending}>{pending ? '登录中…' : '登录'}</button>
{state.error && <p>{state.error}</p>}
</form>
);
}
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:use 和 useMemo/useEffect 名字像但机制一样吗? → 完全不同:use 在渲染期读取 Promise/Context 值,配合 Suspense 处理未就绪态
- 追问2:Actions 和过去 onSubmit+setState 的区别? → 表单提交成为一等公民:useActionState/pending 态内建,自动重置表单
- 追问3:useOptimistic 的适用边界? → 乐观 UI:先展示预期结果,失败回滚;删除/点赞类低风险操作合适
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:React 19 的主线是”数据流内建化”:use 读异步值+Suspense 兜底、Actions 把表单从事件回调变成声明式数据流、useOptimistic 标准化乐观更新。
54. React 错误边界与全局兜底?
概念 Error Boundary 捕获渲染期子树错误(class 组件 componentDidCatch 或 react-error-boundary 库),展示降级 UI;事件回调和异步错误不归它管(要 try/catch 或全局监听)。
典型场景 图表组件数据异常整页白屏;渲染模型返回的富文本崩溃。
解决方案 区块级包裹(图表一个 boundary、聊天流一个);上报 onError;Sentry 类全局兜底。
// 文件: ChartBoundary.tsx
import { ErrorBoundary } from 'react-error-boundary';
// Chart 为图表组件; report 为监控上报函数
<ErrorBoundary
fallback={({ resetErrorBoundary }) => (
<div>图表加载失败 <button onClick={resetErrorBoundary}>重试</button></div>
)}
onError={(e) => report(e)}>
<Chart data={data} />
</ErrorBoundary>
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:错误边界捕不到什么? → 事件回调、异步代码、SSR、它自身——这些要 try/catch 或 window.onerror
- 追问2:boundary 粒度怎么定? → 按路由/关键区块分,粒度过粗整页白屏,过细维护成本高
- 追问3:React 19 里 onError 能拿到什么? → error 与 digest(服务端日志关联用),生产环境不能把 error.message 直接透给用户
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:错误边界是渲染期兜底网(class 组件或 react-error-boundary),按区块粒度部署;异步与事件错误另行捕获。兜底 UI 要给用户出路(重试按钮)而非死白屏。
55. 受控与非受控组件的选择?
概念 受控组件=值由 state 驱动;非受控组件=DOM 自持值。定义:受控——value 由 state 驱动,onChange 同步(强一致,重渲染多);非受控——DOM 自己持有,需要时用 ref 取(defaultValue)。React 19 前 uncontrolled 性能好但难联动;现在大多数场景受控+状态库足够。
典型场景 表单联动校验(受控);文件 input(必然非受控);超大表单卡输入(非受控+局部状态)。
解决方案 常规受控;大表单用 react-hook-form(非受控内核 + 受控注册),性能与功能兼得。
// 文件: rhf-form.tsx
import { useForm } from 'react-hook-form';
interface Credentials { username: string; password: string }
// login 为项目内认证函数
const { register, handleSubmit } = useForm<Credentials>();
// 非受控注册: 输入不触发整表单重渲染
<form onSubmit={handleSubmit(login)}>
<input {...register('username')} /><input {...register('password')} type="password" />
</form>
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:受控输入每键一渲染,性能怎么办? → 正常可接受;真热点用 useDeferredValue 或非受控
- 追问2:非受控怎么取值/校验? → ref 取值,提交时校验;默认值用 defaultValue
- 追问3:动态表单库为什么多走非受控? → 字段多、注册制取值,避免全表单受控的重渲染风暴
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:受控=state 驱动、即时校验/联动强但每键渲染;非受控=ref 提交时取值、简单高效。默认受控,巨型表单用非受控或表单库托管。
56. React Portals 与 Vue Teleport 对应?
概念 createPortal(children, domNode) 将子树渲染到任意节点,事件冒泡仍沿 React 树(方便父级统一处理)。
典型场景 弹窗、Tooltip、全屏抽屉;嵌套 overflow 容器裁剪。
解决方案 弹窗基座统一 portal 到 body + 锁滚动 + ESC 关闭 + 焦点圈定。
// 文件: Modal.tsx
import React, { useEffect } from 'react';
import { createPortal } from 'react-dom';
interface ModalProps { open: boolean; onClose: () => void; children: React.ReactNode }
export function Modal({ open, onClose, children }: ModalProps) {
useEffect(() => {
if (!open) return;
const onKey = (e: KeyboardEvent) => e.key === 'Escape' && onClose();
document.addEventListener('keydown', onKey);
document.body.style.overflow = 'hidden'; // 锁滚动
return () => { document.removeEventListener('keydown', onKey); document.body.style.overflow = ''; };
}, [open, onClose]);
if (!open) return null;
return createPortal(<div className="mask" onClick={onClose}><div onClick={e => e.stopPropagation()}>{children}</div></div>, document.body);
}
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:Portal 的事件归谁? → 冒泡沿 React 组件树而非 DOM 树,父组件能收到 Portal 内容的事件
- 追问2:弹窗里 Esc 关闭怎么实现? → Portal 容器上挂 keydown 监听(或 focus trap 库),注意与全局监听的冲突
- 追问3:无障碍上要注意什么? → focus trap、aria-modal、关闭后焦点归还触发元素
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:Portal 突破 DOM 层级但保留 React 树语义(上下文/事件照常)。弹窗三件套:Portal 渲染 + z-index 令牌 + 焦点管理。
57. React 性能排查:从 Profiler 到优化手段?
概念 性能排查第一步:React DevTools Profiler 录制每次提交,看每次提交的组件耗时与”为什么渲染”(props/state/context 变化);优化三板斧:组件 memo、稳定 props(useMemo/useCallback)、状态下沉/上提。
典型场景 聊天页面每来一个 token 整页重渲染;表格输入一行其他行跟着卡。
解决方案 先把”高频变化的状态”下推到叶子组件(打字机缓冲区放叶子),再谈 memo。
// 文件: state-down.tsx
// Layout/StreamArea 为页面内既有组件
// ❌ 反例: token state 在父组件, 整个页面每次 token 重渲染
// ✅ 正例: 订阅隔离 —— 流状态放独立 hook/子组件
function ChatPage() {
return <Layout><StreamArea /></Layout>; // 只有 StreamArea 内部订阅流
}
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:Profiler 里看什么指标? → 每次提交的 duration 与渲染次数;Flame 图找费时组件,Ranked 找最差的
- 追问2:为什么 memo 了还重渲染? → 引用不稳(props 里新对象/函数)或 context 变化——memo 比较被绕过
- 追问3:怎么量化收益? → 优化前后同操作录制对比:提交次数、总时长、交互延迟
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:性能排查=先测量(Profiler)→定位(费时组件/多余渲染)→针对性修(稳定引用/拆分/虚拟化)→复测。跳过测量直接优化的都是猜。
五、网络协议(58–74)
网络是前后端交界处,也是全栈面试的重点考察区域。本章按一次真实请求的生命周期组织:从 DNS、HTTPS 到 SSE 流式,每节附排查命令。
58. 从 URL 到页面:DNS 解析的分层缓存?
概念 浏览器缓存 → OS hosts/缓存 → 本地 DNS(递归)→ 根 → 顶级域 → 权威 DNS。TTL 控制缓存时长。
典型场景 切域名迁移要控制生效时间;首字节慢要查 DNS 耗时(resource timing 的 domainLookupStart/End)。
解决方案 DNS 预解析 <link rel="dns-prefetch">;关键第三方域名 preconnect(DNS+TCP+TLS 一起提前)。
<!-- 文件: index.html -->
<link rel="preconnect" href="https://llm-gateway.example.com" crossorigin />
<link rel="dns-prefetch" href="https://cdn.example.com" />
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:怎么查一次请求的 DNS 耗时? → Performance API 的 domainLookupStart/End 之差,或 DevTools Network 面板 Timing
- 追问2:改了 DNS 记录多久生效? → 看 TTL;迁移时提前调低 TTL,完成后调回
- 追问3:hosts 文件在解析链的哪一层? → OS 层,优先于本地 DNS 查询
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:DNS 解析逐层找缓存:浏览器→OS→本地 DNS(递归)→根/顶级域/权威。优化就两招:dns-prefetch/preconnect 提前解析,域名迁移提前调 TTL。
59. TCP 三次握手/四次挥手,为什么是三次?
概念 三次握手同步双方初始序列号并确认双向通路(两次无法确认”客户端能收”);四次挥手因半关闭(FIN 后对方还可发数据)。TIME_WAIT 等待 2MSL 防旧报文串扰。
典型场景 面试经典;排查连接数暴涨(TIME_WAIT 过多)。
解决方案 应用层少新建连接——HTTP keep-alive、连接池。
客户端 服务端
│ ── SYN(seq=x) ───────► │
│ ◄── SYN+ACK(seq=y,ack=x+1) ──│
│ ── ACK(ack=y+1) ─────► │ 连接建立
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:两次握手为什么不行? → 服务端无法确认客户端能收,旧 SYN 迟到会建立废连接
- 追问2:TIME_WAIT 为什么是主动关闭方? → 谁先关谁等 2MSL,保证最后一个 ACK 丢失后对方重发 FIN 还能应答
- 追问3:TIME_WAIT 过多怎么治理? → 连接池/长连接复用,必要时调内核 tw_reuse(客户端侧安全)
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:三次握手=同步双方序列号+确认双向可达;四次挥手=半关闭需要四个报文;TIME_WAIT 2MSL 防旧报文串扰。应用层解法是长连接与连接池。
60. HTTPS/TLS 握手:非对称换对称?
概念 TLS 握手用非对称加密交换密钥材料,协商出对称会话密钥,之后全用对称加密——非对称只服务握手阶段,这就是『非对称换对称』。完整流程:客户端 ClientHello(支持的套件+随机数)→ 服务端 ServerHello+证书(含公钥)→ 客户端验证证书链 → ECDHE 密钥协商 → 双方派生对称会话密钥。证书由 CA 链背书防中间人。
典型场景 配置 HTTPS;解释为什么证书过期浏览器拦截;排查 TLS 握手耗时。
解决方案 全站 HTTPS+HSTS;TLS1.3 握手 1-RTT;会话复用降低重复握手。
# 文件: check-tls.sh
curl -sv https://shop.com -o /dev/null 2>&1 | grep -E "SSL connection|subject:|expire"
openssl s_client -connect shop.com:443 -servername shop.com </dev/null 2>/dev/null | openssl x509 -noout -dates
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:中间人拿到证书能伪造吗? → 签名验证不过——CA 私钥不在他手
- 追问2:抓包工具为什么能看 HTTPS? → 安装了自签根证书,信任链被本机信任
- 追问3:对称密钥怎么协商的? → 客户端随机数+服务端随机数+预主密钥,ECDHE 交换
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:TLS 握手=非对称(ECDHE)换对称——证书链验证身份防中间人,协商出的对称密钥跑业务流量。TLS1.3 压到 1-RTT,会话复用免重复握手;全站 HTTPS+HSTS 是基线。
61. HTTP 状态码面试常考清单?
概念 HTTP 状态码表示请求的处理结果。常考清单:2xx 成功(200/204/206 断点续传);3xx 重定向(301 永久/302 临时/304 协商缓存);4xx 客户端错(400 参数/401 未认证/403 无权限/404/429 限流);5xx 服务端错(500/502 网关上游挂/504 上游超时)。
典型场景 接口设计;排查 502(容器挂了)vs 504(容器活着但慢)。
解决方案 按语义选码;AI 网关对上游 LLM 超时返回 504 并带 traceId。
// 文件: nest-llm-gateway.ts
@Post('chat')
async chat(@Body() dto: ChatDto, @Res() res: Response) {
try {
const stream = await this.llm.chatStream(dto); // 上游 SSE
stream.pipe(res.status(200));
} catch (e) {
if (e instanceof UpstreamTimeout) return res.status(504).json({ traceId, message: '模型响应超时' });
return res.status(502).json({ traceId, message: '上游不可用' });
}
}
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:502 和 504 的区别? → 502 网关收到上游无效响应(上游挂了);504 上游超时(活着但太慢)
- 追问2:304 是怎么触发的? → 浏览器带 If-None-Match/If-Modified-Since 发协商请求,资源未变则返回 304 且无 body
- 追问3:401 和 403 的区别? → 401 未认证(不知道你是谁,通常触发重新登录);403 已认证但无权限(重新登录也没用)
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:状态码按语义分段:2xx 成功(200/204/206)、3xx 重定向(301/302/304)、4xx 客户端错(400/401/403/404/429)、5xx 服务端错(500/502/504)。502=上游挂、504=上游慢,排查先分清。
62. 同源策略与 CORS 完整机制?
概念 协议+域名+端口全同才算同源;跨域请求浏览器仍会发出(简单请求直接带,响应被拦;复杂请求先 OPTIONS 预检)。简单请求条件:GET/HEAD/POST + 常规头 + Content-Type 限定(application/x-www-form-urlencoded、multipart/form-data、text/plain)。
典型场景 前端 localhost:5173 调 api.example.com;调第三方 LLM API 带 Authorization 头(必然预检)。
解决方案 后端 CORS 中间件放行指定 Origin+Methods+Headers,带凭证时 Allow-Origin 不能是 *(必须具体域名 + Allow-Credentials: true);开发期 devServer proxy 转发。
// 文件: nest-cors.ts
app.enableCors({
origin: ['https://shop.com', 'http://localhost:5173'],
credentials: true,
methods: ['GET', 'POST', 'PUT', 'DELETE'],
allowedHeaders: ['Content-Type', 'Authorization'],
});
追问预演(面试官顺着答案往深处问,每层接住):
- *追问1:为什么带凭证不能用 ? → 浏览器安全规范强制具体 Origin
- 追问2:OPTIONS 请求能省吗? → 同源/简单请求没有预检;GET+自定义头也躲不掉
- 追问3:CORS 是服务端限制还是浏览器限制? → 浏览器行为,服务端只是声明许可——curl 不受 CORS 限制
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:CORS 是浏览器执行的服务端许可协议:简单请求直发、复杂请求 OPTIONS 预检;带凭证时 Origin 必须具体+Allow-Credentials。curl/服务端间调用不受限——它是浏览器行为。
63. Cookie 属性全解:安全四件套?
概念 Domain/Path 作用域;Expires/Max-Age 生命周期(会话 vs 持久);HttpOnly 防JS 读(抗 XSS 窃取);Secure 仅 HTTPS;SameSite=Lax/Strict/None 防 CSRF。
典型场景 登录态存储选型(JWT 放哪);跨站 iframe 内登录态丢失(第三方 Cookie 被浏览器封杀)。
解决方案 身份 Cookie:HttpOnly+Secure+SameSite=Lax;跨站 SSO 场景 None+Secure(注意浏览器逐步禁第三方 Cookie,改用 Bearer token)。
// 文件: nest-cookie.ts(登录接口内)
@Post('login')
async login(@Body() dto: LoginDto, @Res({ passthrough: true }) res: Response) {
const token = await this.auth.issueRefreshToken(dto);
res.cookie('refresh_token', token, {
httpOnly: true, secure: true, sameSite: 'lax',
maxAge: 7 * 24 * 3600 * 1000, path: '/auth/refresh', // 限定只在刷新接口携带
});
return { ok: true };
}
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:转义了输入为什么还要 CSP? → 转义防注入点,CSP 防漏网(内联脚本被禁)
- 追问2:HttpOnly 挡得住 XSS 吗? → 挡住 Cookie 窃取,挡不住 DOM 操作
- 追问3:React 有 dangerouslySetInnerHTML、Vue 有 v-html,为什么不禁用? → 富文本场景需要,但必须配消毒(DOMPurify)
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:Cookie 安全四件套:HttpOnly 防 XSS 窃取、Secure 限 HTTPS、SameSite 防 CSRF、Expires/Max-Age 控生命周期。身份 Cookie 用 HttpOnly+Secure+Lax;第三方 Cookie 时代落幕,跨站认证改 Bearer。
64. HTTP/1.1 → 2 → 3 的演进主线?
概念 先捋演进主线。HTTP/1.1 长连接但有队头阻塞(一个响应慢堵后面)、6-8 并发连接限制;2 二进制分帧+多路复用(一个连接并行多流)+头部压缩 HPACK,但 TCP 层队头阻塞仍在;3 QUIC/UDP,流独立、连接迁移、0-RTT。
典型场景 资源并发加载策略(h1 时代域名分片,h2 下反而有害);CDN 选型支持 h3。
解决方案 上 h2/h3;禁用域名分片(同一域名才能吃到多路复用)。
# 文件: nginx.conf
listen 443 ssl http2;
listen 443 quic reuseport; # HTTP/3
add_header Alt-Svc 'h3=":443"; ma=86400'; # 告知浏览器可升级
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:HTTP/2 队头阻塞还在吗? → 应用层没了,传输层还在——TCP 丢包阻塞所有流,所以有 HTTP/3
- 追问2:HPACK 解决什么? → 头部字典+哈夫曼编码,重复 header 不再全量传输
- 追问3:HTTP/3 的 QUIC 建连快在哪? → 传输+TLS1.3 握手合一,0/1-RTT;连接迁移靠 Connection ID 不怕换网
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:1.1→2:多路复用/头部压缩/服务端推送;2→3:QUIC 把传输与加密握手合并,根治 TCP 队头阻塞并支持连接迁移。演进主线=降低排队与往返。
65. WebSocket 握手与心跳保活?
概念 WebSocket 用 HTTP 完成『升级』握手:HTTP Upgrade:websocket 握手升级为全双工 TCP;帧协议传输;连接可能被网关/NAT 空闲超时切断,需要心跳。
典型场景 聊天、协同编辑断线;连接”假活”(没断但收不到消息)。
解决方案 客户端定时 ping,超时未收到 pong 判定断线重连(指数退避);重连后补偿拉取缺失消息。
// 文件: ws-heartbeat.ts
class WsClient {
private ws!: WebSocket; private alive = false;
private attempts = 0;
constructor(private url: string, private handleMessage: (data: string) => void) {}
private backoff() { return Math.min(1000 * 2 ** this.attempts++, 30000); } // 指数退避
connect() {
this.ws = new WebSocket(url);
this.ws.onopen = () => this.heartbeat();
this.ws.onmessage = (e) => { this.alive = true; this.handle(e.data); };
this.ws.onclose = () => setTimeout(() => this.connect(), this.backoff());
}
private heartbeat() {
this.alive = false;
this.ws.send(JSON.stringify({ type: 'ping' }));
setTimeout(() => { if (!this.alive) this.ws.close(); }, 5000); // 5s 无 pong 判死
}
// 关键: 心跳必须周期性启动, 不能只挂在 onopen —— 否则只有第一次检查有效
}
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:心跳超时怎么判? → 客户端定时发 ping,两个周期没收到 pong 即判定断线发起重连
- 追问2:重连怎么避免风暴? → 指数退避+抖动,服务端恢复后自然收敛
- 追问3:WS 鉴权怎么做? → 握手 URL 带 token 或首条消息鉴权;Cookie 场景同源自动携带,注意 CSRF
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:WS 握手是 HTTP Upgrade 升级;保活靠心跳(探活)+指数退避重连(防风暴)。代理/网关的空闲超时是心跳存在的根本原因。
66. SSE(Server-Sent Events)与 LLM 流式?
概念 SSE 简而言之就是服务器跟你『直播』:HTTP 长连接单向推。 是 HTTP 长连接的服务端单向推送:Content-Type: text/event-stream,消息以 data: 行为单位,\n\n 分隔;浏览器自动重连(带 Last-Event-ID)。
典型场景 LLM token 流、进度条、通知。POST+鉴权场景用 fetch 流读取(见 67)。
解决方案 服务端分块写出;客户端 reader.read() 循环解码;异常在流中吐出(响应头已发)。
// 文件: nest-sse.controller.ts
@Post('chat')
async chat(@Body() dto: ChatDto, @Res() res: Response) {
res.setHeader('Content-Type', 'text/event-stream; charset=utf-8');
res.setHeader('Cache-Control', 'no-cache');
res.setHeader('X-Accel-Buffering', 'no'); // 关 Nginx 缓冲, 否则流被攒住
try {
for await (const chunk of this.llm.stream(dto.messages)) {
res.write(`data: ${JSON.stringify({ text: chunk })}\n\n`);
}
res.write('data: [DONE]\n\n');
} catch (e) {
res.write(`data: ${JSON.stringify({ error: String(e) })}\n\n`); // 流中报错
} finally {
res.end();
}
}
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:SSE 和 WS 怎么选? → 单向服务端推送 SSE(自动重连/纯 HTTP);双向交互 WS
- 追问2:LLM 流式为什么常用 SSE? → 只需服务端→客户端单向 token 流,SSE 兼容 HTTP 基建(网关/代理/鉴权)成本低
- 追问3:流式响应过代理被缓冲了怎么办? → 关闭代理缓冲(nginx proxy_buffering off),确认 Content-Type: text/event-stream
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:SSE=HTTP 长连接+text/event-stream,服务端单向推、EventSource 自动重连;LLM 打字机输出是典型场景。双向选 WS,单向选 SSE 省心。
67. fetch 读取流:ReadableStream 解码分块?
概念 fetch 拿到的流是一截截到的:response.body 是 ReadableStream,getReader().read() 返回 {done, value(Uint8Array)}。坑在于分块边界不保证按消息对齐,要按分隔符切分缓冲。
典型场景 POST 方式消费 SSE(EventSource 只支持 GET);AI 聊天打字机。
解决方案 TextDecoder 流式解码(stream:true 处理跨块的多字节字符),按 \n\n 切事件。
// 文件: sse-client.ts
export async function ssePost(url: string, body: unknown, onEvent: (data: string) => void, token: string) {
const resp = await fetch(url, {
method: 'POST',
headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${token}` },
body: JSON.stringify(body),
});
if (!resp.ok || !resp.body) throw new Error(`HTTP ${resp.status}`);
const reader = resp.body.getReader();
const decoder = new TextDecoder();
let buf = '';
while (true) {
const { done, value } = await reader.read();
if (done) break;
buf += decoder.decode(value, { stream: true }); // stream:true 处理截断的中文
const parts = buf.split('\n\n');
buf = parts.pop() ?? ''; // 最后一段可能不完整, 留缓冲
for (const p of parts) {
const data = p.replace(/^data: /, '').trim();
if (data === '[DONE]') return;
if (data) onEvent(JSON.parse(data).text);
}
}
}
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:分块边界会切断多字节字符吗? → 会,TextDecoder stream 模式自动保留不完整字节到下一块
- 追问2:SSE 数据帧怎么解析? → 按
分帧,data: 前缀取负载,自己维护缓冲区处理半帧
- 追问3:fetch 流式比 EventSource 强在哪? → 可带自定义头(鉴权)、可中断、支持 POST
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:fetch 读流三步:response.body.getReader()→TextDecoder(stream:true) 解码→按帧分隔符解析。注意半帧缓冲与 UTF-8 多字节边界。
68. 中断请求:AbortController 全场景?
概念 AbortController 是请求的『急刹』:fetch/XHR/axios 均支持 signal;abort 后 fetch 抛 AbortError(要与真实错误区分)。路由切换、重复搜索、组件卸载都应取消。
典型场景 搜索联想竞态(慢的旧响应覆盖新结果);用户关闭页面终止 LLM 调用省 token。
解决方案 每次请求新建 controller,cleanup 里 abort;错误分支放行 AbortError。
// 文件: abort-search.ts
let ctrl: AbortController | null = null;
async function search(q: string) {
ctrl?.abort(); // 取消上一个
ctrl = new AbortController();
try {
const r = await fetch(`/api/search?q=${encodeURIComponent(q)}`, { signal: ctrl.signal });
return await r.json();
} catch (e) {
if ((e as Error).name === 'AbortError') return null; // 主动取消不算错误
throw e;
}
}
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:abort 后 fetch 抛什么错? → AbortError,catch 里按 e.name 区分,与真实网络错误分开处理
- 追问2:AbortSignal.any 干嘛的? → 组合多个信号,任一触发即中止(超时+用户取消并存)
- 追问3:axios 怎么中断? → 传 signal 选项,0.22+ 原生支持 AbortController
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:AbortController 是前端请求中断的标准件:组件卸载清理、竞态取消、超时控制(signal+setTimeout)全靠它。abort 抛 AbortError,记得按名分流。
69. JWT 结构与无状态认证的取舍?
概念 JWT 三段式:header.payload.signature(Base64URL)。两条铁律:签名防篡改但不加密(payload 可解码);无状态=服务端不存 session,代价是无法主动失效——除非引入黑名单或短过期+refresh。
典型场景 前后端分离登录;登出后 token 仍有效的问题。
解决方案 Access 15min + Refresh 7d(HttpOnly Cookie 存、服务端可吊销);敏感操作二次校验。
// 文件: nest-jwt.strategy.ts
async validate(payload: { sub: number }) {
const user = await this.users.findById(payload.sub);
if (!user || user.bannedAt) throw new UnauthorizedException(); // 关键状态仍查库
return user;
}
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:签名能防篡改为什么还要 HTTPS? → 签名防改内容,HTTPS 防窃听
- 追问2:token 泄露了怎么办? → Access 短命+Refresh 可吊销,关键操作二次验证
- 追问3:为什么 payload 用 Base64 不加密? → 设计目标就是可读的签名数据,敏感数据不该放里面
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:JWT=Header.Payload.Signature 三段:签名保证完整性不保密;无状态扩容友好,但撤销难(黑名单/短效+refresh)。放 HttpOnly Cookie 防 XSS,放 localStorage 便于跨域但要防注入。
70. 鉴权三件套对比:Session/Cookie、JWT、OAuth2/OIDC?
概念 三种鉴权各有地盘:Session:服务端存状态,天然可吊销,分布式要 session 共享(Redis);JWT:无状态、跨服务友好,失效控制弱;OAuth2/OIDC:第三方授权登录(授权码+PKCE),ID token 是身份证明。
典型场景 接入 GitHub/微信登录;微服务间认证传递。
解决方案 自家系统 Session 或 JWT 均可;第三方登录走 OAuth2 授权码模式;微服务网关统一鉴权后传用户身份头。
// 文件: oauth-github.ts
// 1. 跳转: https://github.com/login/oauth/authorize?client_id=X&redirect_uri=Y&scope=user
// 2. 回调换 token(服务端, 带 client_secret)
const tokenRes = await fetch('https://github.com/login/oauth/access_token', {
method: 'POST',
headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
body: JSON.stringify({ client_id, client_secret, code, redirect_uri }),
}).then(r => r.json());
// 3. 用 access_token 拉用户信息并建立本地会话
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:JWT 怎么注销? → 黑名单/短有效期+refresh 轮换;无状态是有代价的
- 追问2:OAuth2 的 code 换 token 为什么要在后端? → client_secret 不能暴露在前端,code 交换必须服务端间完成
- 追问3:PKCE 是干嘛的? → 无 secret 的公开客户端(SPA/移动端)防 code 拦截,授权码+验证器配对
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:Session 有状态好撤销、JWT 无状态难注销、OAuth2/OIDC 管第三方授权与身份联合。选型看撤销需求和信任边界,混合方案(短 JWT+refresh)最常见。
71. CDN 原理:就近回源与缓存命中?
概念 访问域名时浏览器首先执行 DNS 解析,分层结构如下: 测度将用户调度至边缘节点;边缘命中直接返回,未命中回源站(回源率是核心指标);静态资源 URL 带 hash 时,CDN 缓存可以放到一年。
典型场景 首屏慢在资源下载;发版后用户看到旧资源(边缘节点没刷新)。
解决方案 发布顺序——先传资源后传 HTML;HTML 不缓存;预热+主动刷新 API;URL 指纹避免刷新依赖。
用户 → 边缘节点(命中? 返回 : 回源并缓存) → 源站
发版: upload assets(hash 文件名) → purge index.html → 用户拿到新 HTML → 新 hash 资源必未命中 → 回源新文件
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:缓存未命中回源慢怎么优化? → 预热(发布时主动拉)、合理 TTL、回源合并(同 key 并发只回源一次)
- 追问2:CDN 怎么知道边缘节点就近? → DNS 调度按用户本地 DNS/EDNS 定位,anycast 路由兜底
- 追问3:动态接口能上 CDN 吗? → 纯动态不能缓存,但可借 CDN 网络加速(动态加速/边缘计算)
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:CDN=边缘缓存+就近调度:静态资源按路径规则缓存,TTL 与刷新策略决定一致性;未命中回源,命中率高则带宽与延迟双降。
72. 接口幂等与防重的前后端配合?
概念 幂等性指同一操作执行多次的效果与执行一次相同。HTTP 语义中 GET/PUT/DELETE 幂等,POST 不幂等。防重:前端防抖仅提升体验,后端唯一约束/幂等键才是保证。HTTP 语义 GET/PUT/DELETE 幂等,POST 不幂等。防重:前端防抖只是体验,后端唯一约束/幂等键才是保证。
典型场景 支付按钮连点;网络重试导致订单重复创建;LLM 调用重复计费。
解决方案 请求头带 Idempotency-Key(前端生成 UUID),服务端 Redis SETNX 记录 key → 结果,重复请求返回第一次结果。
// 文件: nest-idempotency.ts
@Injectable() export class IdempotencyInterceptor implements NestInterceptor {
constructor(private redis: Redis) {}
async intercept(ctx: ExecutionContext, next: CallHandler) {
const req = ctx.switchToHttp().getRequest();
const key = req.headers['idempotency-key'];
if (!key) return next.handle();
// SET NX 原子占位: 并发同 key 只有一个请求真正执行, 其余等待/拒绝
const first = await this.redis.set(key, '__processing__', 'EX', 600, 'NX');
if (first === null) {
const cached = await this.redis.get(key);
return of(cached && cached !== '__processing__' ? JSON.parse(cached) : { code: 409, message: '请求处理中, 请稍后' });
}
return next.handle().pipe(tap(async (body) => {
await this.redis.set(key, JSON.stringify(body), 'EX', 600); // 回写真实结果
}));
}
}
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:SET NX 之后业务失败怎么办? → 占位改状态机:processing→success/failed,失败可重试
- 追问2:窗口期怎么定? → 大于业务最大耗时,一般 5-10 分钟
- 追问3:和数据库唯一索引什么关系? → 唯一索引是最后防线,Redis 是提前拦截,双保险
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:幂等=同一操作重复执行结果不变:前端防重(按钮锁/请求 ID)、服务端幂等(唯一索引/幂等键/去重表)。支付、下单类接口必须端到端幂等设计。
73. 限流算法:令牌桶/漏桶/滑动窗口?
概念 四种限流算法各管一种流量形态:计数器(简单,临界突刺)、滑动窗口(细粒度计数)、漏桶(恒定速率整形)、令牌桶(允许突发,桶内预存令牌)。分布式场景用 Redis+Lua 保证原子。
典型场景 LLM 网关按用户限流(防刷);爬虫对抗;开放接口配额。
解决方案 单机 Nest 用 @nestjs/throttler;分布式用 Redis Lua 令牌桶。
-- 文件: token-bucket.lua (KEYS[1]=key, ARGV: rate, capacity, now, cost)
local rate, capacity, now, cost = tonumber(ARGV[1]), tonumber(ARGV[2]), tonumber(ARGV[3]), tonumber(ARGV[4])
local bucket = redis.call('HMGET', KEYS[1], 'tokens', 'ts')
local tokens = math.min(capacity, (bucket[1] or capacity) + (now - (bucket[2] or now)) * rate / 1000)
local allowed = tokens >= cost
if allowed then tokens = tokens - cost end
redis.call('HMSET', KEYS[1], 'tokens', tokens, 'ts', now)
redis.call('PEXPIRE', KEYS[1], math.ceil(capacity / rate) * 2000)
return allowed and 1 or 0
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:令牌桶允许突发吗? → 允许——桶内存量令牌可瞬间消耗,适合毛刺流量;漏桶恒速整形
- 追问2:滑动窗口比固定窗口好在哪? → 消除边界突刺(两个窗口交界处双倍流量)
- 追问3:分布式限流怎么计数? → Redis+Lua 原子扣减,或网关层统一限流
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:固定窗口简单有突刺,滑动窗口平滑,漏桶恒速整形,令牌桶允许突发。分布式场景用 Redis+Lua 保证计数原子性,返回 429+Retry-After。
74. WebSocket 集群扩散:多实例怎么把消息发给”任意在线用户”?
概念 分布式 WS 的坑:用户可能连在任意一台机器。单机直接内存 map(userId→socket);多实例下用户可能连在任意节点,进程内发送不可达。方案:Redis Pub/Sub 广播(所有节点收到后各自发给本地用户)或按用户路由(网关记录连接归属)。
典型场景 聊天集群部署后消息偶发收不到;通知系统漏发。
解决方案 发布到 Redis channel,每个实例订阅并只发给本地在线的该用户;离线消息落库补拉。
// 文件: nest-ws-gateway.ts
import { WebSocketGateway, WebSocketServer, OnGatewayConnection } from '@nestjs/websockets';
import { Server, IncomingMessage } from 'ws';
import Redis from 'ioredis';
@WebSocketGateway() export class ChatGateway implements OnGatewayConnection {
@WebSocketServer() server: Server;
private local = new Map<number, WebSocket>(); // 本实例在线用户
private sub: Redis; // 订阅端(连接不能复用, 须独立实例)
constructor(private auth: AuthService) {} // 通过 DI 注入
async afterInit() {
// 每个实例都订阅同一频道, 收到消息后只发本地在线的该用户
this.sub = new Redis(process.env.REDIS_URL);
this.sub.subscribe('chat:send');
this.sub.on('message', (_ch, raw) => {
const msg = JSON.parse(raw) as { to: number; payload: unknown };
const socket = this.local.get(msg.to);
if (socket?.readyState === WebSocket.OPEN) socket.send(JSON.stringify(msg.payload));
});
}
async handleConnection(client: WebSocket, req: IncomingMessage) {
const userId = await this.auth.fromHandshake(req);
this.local.set(userId, client);
}
handleDisconnect(client: WebSocket) {
for (const [uid, s] of this.local) if (s === client) this.local.delete(uid); // 防泄漏
}
// 发消息: 发布到 Redis, 所有实例(含本机)都会收到并各自尝试投递
send(userId: number, payload: unknown) {
const pub = new Redis(process.env.REDIS_URL); // 生产中应注入共享发布端, 此处示意
pub.publish('chat:send', JSON.stringify({ to: userId, payload }));
}
}
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:Redis Pub/Sub 丢消息怎么办? → 会丢(无持久化),强可靠用 Redis Stream 或消息队列,离线消息落库补拉
- 追问2:怎么知道用户连在哪台实例? → 连接时上报 userId→instanceId 到 Redis,定向投递省广播;小规模广播够用
- 追问3:实例扩缩容时连接怎么迁移? → 优雅关闭:停止新连接、广播让客户端重连到其他实例
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:集群 WS 两条路:Redis Pub/Sub 全广播简单但不可靠,定向路由省资源但要维护连接归属表。离线消息一律落库补拉兜底。
六、大文件上传与传输(75–87)
大文件上传覆盖分片、hash 计算、断点续传、直传签名等环节,每个环节均可深入追问。本章代码为完整可还原方案。
75. 大文件上传为什么必须分片?
概念 为什么大文件必须切片?整文件上传有四宗罪:单请求超时/网关 body 限制(nginx client_max_body_size)、失败全重来、无法并发。分片=切片独立上传+服务端合并,支持并发、断点续传、秒传。
典型场景 模型数据集/视频/数据备份上传;移动端弱网传大图。
解决方案 切片 5–10MB;每片算 hash;并发上传(池控制);全片完成后调合并接口;上传前查 hash 秒传。
// 文件: uploader/slice.ts
export function sliceFile(file: File, size = 8 * 1024 * 1024) {
if (!Number.isInteger(size) || size <= 0) throw new RangeError('size 必须为正整数'); // 防 size=0 死循环
const chunks: { blob: Blob; index: number }[] = [];
for (let i = 0; i * size < file.size; i++)
chunks.push({ blob: file.slice(i * size, (i + 1) * size), index: i });
return chunks;
}
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:片多大合适? → 5-10MB,太小请求多,太大重传成本高
- 追问2:hash 算整文件还是每片? → 整文件用于秒传,每片用于校验
- 追问3:并发几路? → 3-5,看带宽和服务端承压
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:大文件分片解决四宗罪:超时/体积限制/失败全重传/无并发。5-10MB 切片+每片 hash+并发池(3-5)+合并接口+秒传判断,构成上传方案的最小完备集。
76. 秒传:文件 hash 的计算与体验优化?
概念 秒传的原理是先比对文件 hash 再决定是否传输:上传前算整文件 hash,服务端已存在同 hash 文件则直接关联,实现”秒传”。大文件全量读入算 hash 会卡 UI——用 Web Worker + 增量读取抽样/全量分片 hash。
典型场景 网盘类产品;重复导入同一数据集。
解决方案 Worker 里 SparkMD5 按分片增量计算,主线程不卡;hash 作用:秒传判断+分片校验+合并完整性。
// 文件: uploader/hash.worker.js
importScripts('https://cdn.jsdelivr.net/npm/spark-md5@3.0.2/spark-md5.min.js');
self.onmessage = async ({ data: { file, chunkSize } }) => {
const spark = new SparkMD5.ArrayBuffer();
for (let i = 0; i * chunkSize < file.size; i++) {
const buf = await file.slice(i * chunkSize, (i + 1) * chunkSize).arrayBuffer();
spark.append(buf);
self.postMessage({ progress: ((i + 1) * chunkSize) / file.size });
}
self.postMessage({ hash: spark.end() }); // 整文件 md5
};
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:为什么抽样 hash 不能保证强一致? → 只采样部分分片,理论存在碰撞漏判;严格场景全量 hash
- 追问2:Worker 里能用 file.slice 吗? → 能,File/Blob 引用可传给 Worker,切片读取仍在浏览器文件系统层
- 追问3:MD5 之外用什么? → SHA-256(crypto.subtle 原生支持),MD5 仅因生态成熟仍广泛用于秒传
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:秒传=上传前 hash 比对;大文件 hash 用 Web Worker+分片增量计算防卡 UI。hash 复用三处:秒传判断、分片校验、合并完整性。
77. 断点续传:已传分片怎么跳过?
概念 断点续传的核心一句话:续传=上传前问服务端”这个 hash 哪些分片已经有了”,只传缺的。服务端记录 fileHash → 分片列表;全片到齐触发合并。
典型场景 传 2GB 数据集断网重传;用户刷新页面后继续。
解决方案 localStorage/IndexedDB 记本地进度(可选),以服务端返回为准(多端一致)。
// 文件: uploader/resume.ts
async function upload(file: File) {
const hash = await computeHash(file); // 见 76
const { done, uploaded } = await api.check(hash); // 服务端已有?
if (done) return { url: uploaded }; // 秒传
const chunks = sliceFile(file);
await pool(
chunks.filter((_, i) => !uploaded.includes(i)), // 只传缺片
(c) => api.uploadChunk({ hash, index: c.index, blob: c.blob }),
3,
);
return api.merge({ hash, total: chunks.length, filename: file.name }); // 服务端合并
}
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:check 接口返回什么结构? → 已传分片索引数组+是否已完成,前端据此过滤待传列表
- 追问2:本地进度和服务端进度冲突听谁的? → 服务端;本地记录只为快速预筛,最终以 check 为准
- 追问3:分片重复上传会怎样? → 服务端按 hash+index 原子覆盖/跳过,需幂等设计
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:断点续传=上传前 check(返回已传分片列表)→只传缺片→全片到齐触发 merge。多端一致以服务端为准,分片接口幂等。
78. 服务端(Nest)如何接分片与合并?
概念 服务端按 hash 分目录暂存分片:uploadChunk 按格子存(fileHash+index+分片文件),落盘到临时目录 {hash}/{index};merge 接口校验分片数,按序拼接为最终文件(流式 append,避免一次性读内存),写库登记。
典型场景 自建上传服务;对接 MinIO 前的中转。
解决方案 multer 接分片;fs.createReadStream/writeStream 管道合并;合并后校验整体 hash。
// 文件: nest/upload.service.ts
@Injectable() export class UploadService {
async saveChunk(hash: string, index: number, file: Express.Multer.File) {
if (!/^[a-f0-9]{32,64}$/i.test(hash) || !Number.isInteger(index) || index < 0)
throw new BadRequestException('非法分片参数'); // hash/index 来自用户, 不校验就是路径穿越
const dir = join(TMP_DIR, hash);
await mkdir(dir, { recursive: true });
await writeFile(join(dir, String(index)), file.buffer);
return { received: true };
}
async merge(hash: string, total: number, name: string) {
if (!/^[a-f0-9]{32,64}$/i.test(hash)) throw new BadRequestException('非法 hash');
const dir = join(TMP_DIR, hash);
const target = createWriteStream(join(STORE_DIR, hash + extname(name)));
for (let i = 0; i < total; i++) {
await pipeline(createReadStream(join(dir, String(i))), target, { end: false });
}
target.end();
await rm(dir, { recursive: true }); // 清理分片
return { url: `/files/${hash}${extname(name)}` };
}
}
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:合并时服务端挂了怎么办? → 分片还在,重新调 merge 即可(幂等设计)
- 追问2:怎么验证合并结果完整? → 合并后算整体 hash 比对
- 追问3:分片丢失一片怎么办? → 前端重传缺失片,服务端返回缺失列表
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:服务端接分片=按 hash 建目录、分片按 index 落盘、merge 按序流式拼接+清理;hash/index 必须校验防路径穿越。合并幂等可重入,分片丢失返回缺失列表。
79. 直传 OSS/MinIO:预签名 URL 方案?
概念 直传的核心是后端仅签发凭证,不参与文件流传输:后端不中转文件流,只签发”允许 PUT 指定 key 一段时间”的预签名 URL;前端直传对象存储;完成后回调/前端通知后端写库。优点:省服务器带宽内存;凭证不过期不过界。
典型场景 头像/数据集/聊天附件;阿里云 OSS、S3、MinIO 同构支持。
解决方案 后端 PutObjectCommand + getSignedUrl(带 content-type 与过期);前端 fetch PUT。
// 文件: nest/presign.service.ts
async presign(name: string, type: string) {
const key = `uploads/${dayjs().format('YYYYMMDD')}/${randomUUID()}-${name}`;
const cmd = new PutObjectCommand({ Bucket: BUCKET, Key: key, ContentType: type });
return { url: await getSignedUrl(this.s3, cmd, { expiresIn: 600 }), key };
}
// 文件: api/presign-upload.ts
const { url, key } = await api.post('/presign', { name: file.name, type: file.type });
await fetch(url, { method: 'PUT', body: file, headers: { 'Content-Type': file.type } });
await api.post('/files/complete', { key, size: file.size }); // 登记
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:预签名 URL 泄露了怎么办? → 过期时间短+key 随机+后端校验最终归属
- 追问2:为什么不用 STS 临时凭证? → 也可以——签名 URL 更简单,STS 适合多次操作场景
- 追问3:回调失败文件就成孤儿了怎么办? → 对账任务+孤儿清理定时任务
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:预签名 URL 直传=后端只发凭证不碰文件流:省服务器带宽,前端直传 OSS;短有效期+随机 key+归属校验兜安全。回调失败靠对账任务清理孤儿。
80. 分片直传 MinIO 的合并替代:Multipart Upload?
概念 自己写合并能跑,但对象存储原生就有 multipart upload:(init 上传 id → 分片上传 → complete 合并),服务端合并逻辑不需要自己写,断点续传用 ListParts 查已传分片。
典型场景 超大文件(GB+)直传;自研 merge 不想背。
解决方案 后端只管 init/complete 签名,前端拿每个分片的预签名 URL 并发传。
// 文件: nest/multipart.service.ts
async init(name: string) {
const { UploadId } = await this.s3.send(new CreateMultipartUploadCommand({ Bucket: BUCKET, Key: name }));
return UploadId;
}
async partUrls(key: string, uploadId: string, partNumbers: number[]) {
return Promise.all(partNumbers.map(async (n) => ({
partNumber: n,
url: await getSignedUrl(this.s3, new UploadPartCommand({ Bucket: BUCKET, Key: key, UploadId: uploadId, PartNumber: n }), { expiresIn: 600 }),
})));
}
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:Multipart 和自研分片合并怎么选? → 对接 S3/MinIO 优先原生 multipart:免自研合并、天然断点续传(ListParts)
- 追问2:分片大小有约束吗? → S3 生态除最后一片外需等大(如 5MB+),片数有上限(10000),过大过小都要权衡
- 追问3:废弃的上传怎么清理? → AbortMultipartUpload;设置生命周期规则自动清理未 complete 的碎片
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:对象存储原生 Multipart Upload(init→分片→complete)替代自研合并,ListParts 查进度、AbortMultipartUpload 清理。自研方案仅在无对象存储时考虑。
81. 上传进度与并发控制:XHR 与 fetch 的差异?
概念 冷知识:fetch 拿不到上传进度——request body 无进度回调,上传进度要用 XMLHttpRequest 的 upload.onprogress;下载进度可用 fetch 的 content-length + 已读累计。
典型场景 上传大文件的进度条;多分片聚合总进度。
解决方案 axios 本身基于 XHR 自带 onUploadProgress;分片进度 = 完成片数/总片数(简单准确)。
// 文件: uploader/progress.ts
function uploadChunk(url: string, blob: Blob, onProgress: (pct: number) => void) {
return new Promise<void>((resolve, reject) => {
const xhr = new XMLHttpRequest();
xhr.open('PUT', url);
xhr.upload.onprogress = (e) => e.lengthComputable && onProgress(e.loaded / e.total);
xhr.onload = () => (xhr.status < 300 ? resolve() : reject(new Error(String(xhr.status))));
xhr.onerror = () => reject(new Error('network'));
xhr.send(blob);
});
}
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:fetch 能拿到上传进度吗? → 不能(请求体流不可读进度),要进度用 XMLHttpRequest.upload.onprogress
- 追问2:并发池怎么实现? → 固定 N 个 worker 循环取任务,完成一个补一个,失败放回重试
- 追问3:整体进度怎么算? → 汇总各片已传字节/总字节;合并完成才算 100%
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:进度条用 XHR(upload.onprogress),fetch 无上传进度;并发用池(3-5 路)平衡速度与网关压力。进度按字节聚合,别按分片数。
82. 大文件下载:流式与断点续传(Range)?
概念 下载端同理『边流边给』:服务端用流(不整文件进内存)+ 支持 Range 头(断点续传、多线程下载);返回 206 Partial Content + Content-Range。前端下载大文件用 a[download]+流式,或 StreamSaver 落盘。
典型场景 导出百万行数据 CSV;下载模型产物。
解决方案 Nest 用 StreamableFile;浏览器自动带 Range 时响应 206。
// 文件: nest/download.controller.ts
@Get('export')
@Header('Content-Type', 'text/csv; charset=utf-8')
download(@Query('task') task: string): StreamableFile {
// task 来自用户输入, 白名单校验防路径穿越 (../../etc/passwd)
if (!/^[A-Za-z0-9_-]+$/.test(task)) throw new BadRequestException('非法任务标识');
const stream = createReadStream(csvPath(task));
return new StreamableFile(stream); // Node 流直接交给框架, 支持自动 Range(配合框架)
}
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:Range 请求谁支持? → 服务端需支持 Accept-Ranges: bytes 并处理 Range 头,返回 206
- 追问2:怎么验证合并后的区间对不对? → 响应带 Content-Range,前端可校验长度;关键文件配 ETag 防中途变更
- 追问3:视频拖拽播放为什么快? → 播放器按需发 Range 请求,不用下整文件
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:下载断点续传=HTTP Range+206;浏览器自动续点(下载管理器),前端大文件下载用流式读取落盘。服务端支持 Accept-Ranges 是前提。
83. 导出超大 Excel 的工程方案?
概念 全量生成 xlsx 会导致内存溢出。方案:分页查询 + 流式写(csv 流最简单);xlsx 用 ExcelJS streaming workbook writer;超大数据集拆多文件打包 zip。
典型场景 运营导出百万行订单;AI 平台导出评测明细。
解决方案 游标分页(offset 大了慢,用 id > lastId 游标)→ 行批写入 → HTTP 流式响应(边生成边下载)。
// 文件: nest/export.service.ts
async *iterateOrders(): AsyncGenerator<Order> {
let lastId = 0;
while (true) {
const batch = await this.repo.find({ where: { id: MoreThan(lastId) }, order: { id: 'ASC' }, take: 1000 });
if (!batch.length) return;
lastId = batch[batch.length - 1].id;
yield* batch;
}
}
async exportToStream(res: Response) {
res.setHeader('Content-Type', 'text/csv; charset=utf-8');
res.write('\uFEFFid,amount\n'); // \uFEFF 为 BOM, 防 Excel 中文乱码
for await (const o of this.iterateOrders()) res.write(`${o.id},${o.amount}\n`);
res.end();
}
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:前端生成 Excel 为什么会崩? → 全量数据进内存构建工作簿,10万行+样式轻松 OOM
- 追问2:流式导出怎么做? → 服务端游标分批查库,流式写 xlsx(SXSSFWorkbook/write stream),响应头 Content-Disposition
- 追问3:导出任务量大怎么削峰? → 异步任务+消息队列:提交任务→后台生成→上传 OSS→站内信给下载链接
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:超大 Excel 导出走服务端流式生成(游标分批+流式写),超大请求走异步任务队列,完成后给 OSS 下载链接。前端只做触发与下载,不做生成。
84. 前端下载二进制与文件名乱码?
概念 下载的文件名乱码,病根在后端 Content-Disposition 的中文文件名要用 RFC 5987 编码(filename*=UTF-8”…)或前端从响应头解析;blob + a[download] 触发保存。
典型场景 下载 CSV/Excel 中文名乱码;blob 下载无法显示进度。
解决方案 前端 blob 下载 + decodeURIComponent;或后端设置 attachment; filename*=UTF-8''${encodeURIComponent(name)}。
// 文件: download-blob.ts
async function downloadFile(url: string, fallback = 'download') {
const resp = await fetch(url, { headers: authHeaders() });
const disposition = resp.headers.get('Content-Disposition') ?? '';
const name = decodeURIComponent(disposition.match(/filename\*=UTF-8''([^;]+)/)?.[1] ?? fallback);
const blob = await resp.blob();
const a = Object.assign(document.createElement('a'), { href: URL.createObjectURL(blob), download: name });
a.click();
URL.revokeObjectURL(a.href); // 及时释放
}
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:为什么文件名会乱码? → Content-Disposition 里的中文需 RFC 5987 编码,老服务端直接放 UTF-8 原文
- 追问2:filename 语法是什么?* →
filename*=UTF-8''%E6%8A%A5%E5%91%8A.pdf,encodeURIComponent 生成 - 追问3:a.download 属性什么时候生效? → 同源或 blob: URL 生效;跨域 URL 被浏览器忽略,靠响应头决定文件名
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:下载二进制=fetch+blob+createObjectURL,a.download 定名;文件名乱码根因在服务端 Content-Disposition 编码(filename*+RFC 5987)。跨域下载文件名只能靠服务端。
85. 图片上传的前端处理:压缩与方向?
概念 手机拍图自带 EXIF 方向的坑:,canvas 绘制会转 90 度;大图(5MB+)应压缩后再传(质量/尺寸限制)。现代浏览器 createImageBitmap 解析快且能处理 EXIF 选项。
典型场景 头像上传、聊天发图;不同浏览器方向不一致。
解决方案 createImageBitmap(file, { imageOrientation: ‘from-image’ }) 统一方向 → canvas 缩放 → toBlob(quality 0.85)。
// 文件: image-compress.ts
export async function compressImage(file: File, maxSide = 1920, quality = 0.85): Promise<Blob> {
const bmp = await createImageBitmap(file, { imageOrientation: 'from-image' });
const scale = Math.min(1, maxSide / Math.max(bmp.width, bmp.height));
const canvas = new OffscreenCanvas(bmp.width * scale, bmp.height * scale);
canvas.getContext('2d')!.drawImage(bmp, 0, 0, canvas.width, canvas.height);
return canvas.convertToBlob({ type: 'image/jpeg', quality });
}
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:EXIF 方向为什么会出现? → 手机按持握方向存 Orientation 标记,渲染器按标记旋转;iOS 拍照上传常踩
- 追问2:canvas.toBlob 能压缩到指定体积吗? → 不能精确,二分质量参数逼近目标体积
- 追问3:压缩在主线程卡怎么办? → createImageBitmap+OffscreenCanvas 或 Web Worker 处理
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:前端图片处理两件事:createImageBitmap 自动应用 EXIF 方向、canvas 重绘+toBlob 压缩控体积。大图处理搬进 Worker 防卡顿。
86. 粘性上传:弱网下的重试与退避策略?
概念 弱网三大纪律:分片粒度让重试成本=一片、退避要指数、连续失败要停。网络抖动导致分片失败,立即重试会雪上加霜;指数退避 + 抖动(jitter)是标准策略;分片粒度让重试成本=一片。
典型场景 移动网络切换 WiFi/蜂窝;上传中途断网自动恢复。
解决方案 单片最多重试 3 次(退避 1s/2s/4s+随机);连续失败暂停并提示用户手动恢复。
// 文件: uploader/retry.ts
export async function retry<T>(fn: () => Promise<T>, times = 3): Promise<T> {
for (let i = 0; ; i++) {
try { return await fn(); }
catch (e) {
if (i >= times - 1) throw e;
const delay = 2 ** i * 1000 + Math.random() * 500; // 指数退避 + jitter
await new Promise(r => setTimeout(r, delay));
}
}
}
// 用法: await retry(() => uploadChunk(url, blob, onProgress))
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:重试放大问题是什么? → 弱网下大量分片同时重试打满网关;限并发+退避+失败阈值熔断
- 追问2:退避上限多少合适? → 如 30s 封顶,超过提示用户手动重试,别无限等
- 追问3:网络恢复怎么感知? → online 事件不可靠,真实探测是发轻量探针请求成功后再续传
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:弱网上传三板斧:指数退避+抖动防重试风暴、失败阈值熔断转手动、网络探针确认恢复再续传。核心是失败也讲秩序。
87. 上传安全:类型校验与病毒墙?
概念 安全第一课:前端的一切校验都是建议,后端的才是法律。前端 MIME/后缀校验都可绕过;服务端要校验魔数(文件头)、大小限制、存储 key 不可控、下载 Content-Type 防直执行(HTML 变存储型 XSS)。
典型场景 开放上传的平台;上传的 svg 内嵌脚本。
解决方案 后端读文件头比对魔数;下载响应 Content-Disposition: attachment+X-Content-Type-Options: nosniff;图片二次压缩即”重编码杀毒”。
// 文件: nest/magic-check.ts
const MAGIC: Record<string, number[]> = {
jpg: [0xff, 0xd8, 0xff], png: [0x89, 0x50, 0x4e, 0x47], pdf: [0x25, 0x50, 0x44, 0x46],
};
function checkMagic(buf: Buffer, type: string) {
const head = [...buf.subarray(0, 4)];
return MAGIC[type]?.every((b, i) => head[i] === b) ?? false;
}
// 使用: if (!checkMagic(file.buffer, 'png')) throw new BadRequestException('文件类型不符');
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:前端校验能绕过吗? → 能,安全判定全在服务端:magic number+服务端重命名+隔离存储
- 追问2:图片二次渲染为什么能消毒? → 解码再编码会剥离恶意载荷,但保留内容
- 追问3:病毒墙扫什么? → ClamAV 等引擎扫上传文件,异步扫描时先隔离后放行
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:上传安全四层:前端预检(体验)、服务端 magic number+白名单(真实防线)、存储隔离+随机文件名(防执行)、病毒扫描+二次渲染(消毒)。前端校验只是体验优化。
七、性能优化(88–99)
性能优化的正确顺序:先建立度量基线,再按指标(LCP/INP/CLS)逐项分析原因与对策,最后通过 CI 门禁机制防止性能劣化回退。
88. 性能指标体系:Core Web Vitals 与采集?
概念 三项核心指标(Core Web Vitals):LCP(Largest Contentful Paint,最大内容绘制,目标 <2.5s,衡量首屏主内容出现速度);INP(Interaction to Next Paint,交互到下一次绘制,目标 <200ms,衡量点击/输入的响应速度);CLS(Cumulative Layout Shift,累积布局偏移,目标 <0.1,衡量页面稳定性)。辅助指标:FCP(首次内容绘制)、TTFB(首字节时间)。
怎么获取这些指标——两条途径,分开发与线上:
- 本地测量(开发期):Chrome DevTools → Performance 面板录制(可看 LCP/CLS 逐帧);Lighthouse 面板(套件评分);命令行
npx lighthouse <url>。注意 DevTools 的数值是”你这台机器”的,要用 CPU 4x Slowdown 模拟低端设备。 - 线上采集(真实用户,RUM):浏览器把指标暴露为 PerformanceEntry,用
PerformanceObserver监听(见下方代码);或直接用 Google 官方web-vitals库,它封装了各指标的取法、归一化和上报时机(指标可能在页面卸载时才最终确定,库会自动在合适时机上报)。两种方式都要上报到自己的服务端聚合,看 P75 而非平均值。
典型场景 优化前先立基线;老板问”页面为什么慢”。
解决方案 web-vitals 采集上报,按设备/页面聚合看 P75。
原生写法(PerformanceObserver,理解指标从哪来):
// 文件: monitoring/perf-observer.ts
// LCP: 类型为 'largest-contentful-paint'; 页面会持续产生候选, 取最后一个
new PerformanceObserver((list) => {
const entries = list.getEntries();
const lcp = entries[entries.length - 1]; // 最大内容元素可能变化, 以最后一次为准
console.log('LCP:', lcp.startTime, lcp.element);
}).observe({ type: 'largest-contentful-paint', buffered: true }); // buffered: 补发 observer 注册前的记录
// CLS: 类型为 'layout-shift'; 只统计无用户输入引发的偏移(hadRecentInput 为 true 的跳过)
let cls = 0;
new PerformanceObserver((list) => {
for (const e of list.getEntries()) {
if (!e.hadRecentInput) cls += e.value; // 累加每次偏移分值
}
console.log('CLS:', cls);
}).observe({ type: 'layout-shift', buffered: true });
// TTFB: navigation timing 里的 responseStart - requestStart
const nav = performance.getEntriesByType('navigation')[0];
console.log('TTFB:', nav.responseStart - nav.requestStart);
// INP 较特殊: 事件时长归到 event timing 条目, 手写归一化繁琐 —— 实际项目直接用 web-vitals 库
推荐写法(web-vitals 库,处理了上报时机与兼容性):
// 文件: monitoring/web-vitals.ts
import { onLCP, onINP, onCLS, onFCP } from 'web-vitals';
const send = (m: { name: string; value: number }) =>
navigator.sendBeacon('/api/metrics', JSON.stringify({ ...m, page: location.pathname, ts: Date.now() }));
// sendBeacon 在页面卸载时也能可靠发出(普通 fetch 会丢) —— 指标常常在用户离开页面前才最终确定
onLCP(send); onINP(send); onCLS(send); onFCP(send);
追问预演(面试官顺着答案往深处问,每层接队):
- 追问1:为什么看 P75 不看平均值? → 平均值被极端值拉偏,Google 以 P75 定义达标,反映大多数真实用户
- 追问2:INP 为什么替代 FID? → FID 只测首次交互延迟,INP 覆盖整页交互的响应性(含处理+绘制)
- 追问3:实验室数据和 RUM 对不上怎么办? → 以 RUM 为准(真实用户),实验室仅回归用;注意设备分布差异
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:三大 CWV:LCP<2.5s、INP<200ms、CLS<0.1;本地 DevTools/Lighthouse、线上 PerformanceObserver/web-vitals+sendBeacon 上报看 P75。
89. LCP 优化:首屏最大元素为什么慢?
概念 LCP 慢,先定位『最大内容』元素——通常是首图/大标题,用 DevTools Performance 面板或 PerformanceObserver(‘largest-contentful-paint’)找到元素与耗时。慢因:资源晚发现(CSS 背景图)、服务器慢、被其他资源抢带宽、懒加载误伤首图。
典型场景 首屏大 banner 图 LCP 超标;SSR 页仍慢。
解决方案 首图 <img src>+fetchpriority="high"+preload,明确尺寸防 CLS;关键 CSS 内联;HTML 文档不缓存保证发现新资源。
<!-- 文件: index.html -->
<link rel="preload" as="image" href="/hero.avif" fetchpriority="high" />
<img src="/hero.avif" width="1280" height="720" fetchpriority="high" decoding="async" alt="" />
<!-- 注意: 首屏图禁用 loading="lazy" -->
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:LCP 元素怎么确定? → DevTools Performance 面板有 LCP 标记,或 largest-contentful-paint API
- 追问2:图片加载快但 LCP 仍慢? → 发现晚(HTML 解析才看到),上 preload/fetchpriority
- 追问3:SSR 能救 LCP 吗? → 能救发现时机,图片本身还是要优化
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:LCP 慢的三大根因:慢服务器(TTFB)→渲染阻断资源→晚发现资源。解法链:SSR/SSG 提前出内容、preload 关键资源、压缩图片用现代格式、CDN 就近。
90. INP 优化:长任务拆分与调度?
概念 INP 差说明交互回调中存在长任务(>50ms)。定位:Performance 面板的 Event Log 或 Long Tasks observer 找到超时回调;治理手段:任务切片(scheduler.yield/MessageChannel)、非紧急工作放 requestIdleCallback/startTransition、重计算搬进 Web Worker。
典型场景 大表格筛选计算 300ms 掉帧;搜索触发同步 diff。
解决方案 计算型任务 Worker 化;UI 更新用 transition 降级优先级。
// 文件: yield-task.ts
export function nextFrame(): Promise<void> {
return new Promise(r => requestAnimationFrame(() => setTimeout(r, 0)));
}
export async function chunkedRun<T>(items: T[], fn: (item: T) => void, budgetMs = 16) {
const start = performance.now();
for (const it of items) {
fn(it);
if (performance.now() - start > budgetMs) { // 让出一帧给交互
await nextFrame();
}
}
}
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:长任务多少算长? → >50ms 就影响交互
- 追问2:为什么是 50ms? → 100ms 响应感知阈值减去输入处理和渲染余量
- 追问3:Web Worker 通信成本大怎么办? → Transferable Objects 零拷贝转移,或 SharedArrayBuffer
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:INP 差=长任务堵主线程:拆任务(scheduler.yield/setTimeout 切片)、输入处理优先(useTransition 降级低优更新)、大计算进 Worker。目标:交互 200ms 内出反馈。
91. CLS 优化:布局偏移的经典来源?
概念 布局偏移三大来源:无尺寸的图片/广告位、动态插入内容顶开下方、字体加载切换(FOUT)。CLS 累计所有意外偏移。
典型场景 图片加载完页面跳一下;banner 异步渲染把内容推下去。
解决方案 所有媒体写 width/height(aspect-ratio);骨架屏占位;字体 font-display: optional/swap+preload。
<!-- 文件: cls-fix.html -->
<img src="/a.jpg" width="800" height="450" alt="" style="aspect-ratio: 16/9; object-fit: cover" />
<div class="ad-slot" style="min-height: 250px"></div> <!-- 广告位预留高度 -->
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:图片撑开布局怎么防偏移? → width/height 属性(现代浏览器自动算 aspect-ratio)预留占位
- 追问2:字体加载为什么会偏移? → FOUT 期间 fallback 字体度量不同;size-adjust/ascent-override 对齐度量
- 追问3:动态插入 banner 怎么不抖? → 容器预留 min-height,插入后替换而非推挤
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:CLS 三大来源:无尺寸媒体(补 width/height)、web 字体交换(size-adjust 对齐)、动态注入内容(预留空间)。偏移的本质=浏览器收到信息时已渲染完旧布局。
92. 包体积:bundle analyzer 驱动的减脂清单?
概念 优化前先量化:先量化(analyzer 看大头),再动手:按需引入组件库、moment→dayjs、lodash-es 按需、moment locale 剔除、重复依赖(dedupe)、动态 import 分包、压缩(生产 esbuild/swc minify)。
典型场景 首屏 JS >1MB;vendor 包占 60%。
解决方案 Vite 用 rollup-plugin-visualizer 产出 treemap,按图索骥。
// 文件: vite.config.ts
import { defineConfig } from 'vite';
import { visualizer } from 'rollup-plugin-visualizer';
export default defineConfig({
plugins: [visualizer({ filename: 'stats.html', gzipSize: true })],
build: { rollupOptions: { output: { manualChunks: { vendor: ['vue', 'vue-router'], editor: ['echarts'] } } } },
});
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:tree-shaking 失效的常见原因? → CJS 依赖、副作用模块(sideEffects 未配)、动态访问导出
- 追问2:day.js 和 moment 差在哪? → 不可变 API+按需 locale,体积差一个数量级;date-fns 同理 tree-shakable
- 追问3:manualChunks 怎么拆才对? → 按访问频率分层:框架(高频稳定)与重组件(低频)分离,利用缓存
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:包体积优化=analyzer 定位→替换重组件→按需引入→tree-shaking 生效检查(sideEffects)→manualChunks 分层缓存。有数字(前后对比)才叫优化。
93. 渲染层优化:重排/重绘与合成层?
概念 浏览器渲染有『价格表』:改几何(宽高位置)=重排(贵);改颜色=重绘;transform/opacity 只在合成层(GPU)不触发重排。频繁读布局再写布局会强制同步布局(layout thrashing)。
典型场景 动画卡;scroll 里读写 offsetTop 交错。
解决方案 动画只用 transform/opacity;批量读写分离(FastDOM 思想);will-change 提升合成层(节制)。
// 文件: batch-dom.js
const els = [...document.querySelectorAll('.card')];
// ❌ 反例: 读写交错 N 次强制布局
// ✅ 正例: 先批量读, 再批量写
const heights = els.map(el => el.offsetTop);
els.forEach((el, i) => (el.style.transform = `translateY(${heights[i]}px)`));
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:transform 为什么快? → 合成器线程执行,不进主线程布局/绘制流水线,不阻塞 JS
- 追问2:will-change 滥用的代价? → 每层占 GPU 内存,层数过多反而掉帧——用到即建,用完移除
- 追问3:怎么定位 layout thrashing? → DevTools Performance 面板大量紫色 Layout 连环块;读布局属性交错写就是元凶
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:改几何=重排(贵)、改颜色=重绘、transform/opacity=仅合成(免费档);读写分离治 layout thrashing。动画永远走 transform/opacity。
94. 虚拟列表完整实现思路?
概念 虚拟列表思路简单粗暴:只渲染可视区+缓冲:容器定高滚动,内部撑总高,可见项绝对定位偏移。不定高需测量缓存位置数组+二分查找起点;动态高度用 ResizeObserver 更新缓存。
典型场景 AI 聊天千条消息、万行表格。
解决方案 优先用成熟库(Vue Virtual Scroller/react-window),理解原理才能处理不定高+反向(从底部开始)场景。
// 文件: VirtualList.tsx (定高简化版)
// VListProps: { items: T[]; rowHeight: number; height: number; render: (item: T, index: number) => React.ReactNode }
export function VirtualList({ items, rowHeight = 48, height = 600, render }: VListProps) {
const [scrollTop, setScrollTop] = useState(0);
const start = Math.max(0, Math.floor(scrollTop / rowHeight) - 5);
const count = Math.ceil(height / rowHeight) + 10;
const visible = items.slice(start, start + count);
return (
<div style={{ overflow: 'auto', height }} onScroll={e => setScrollTop(e.currentTarget.scrollTop)}>
<div style={{ height: items.length * rowHeight, position: 'relative' }}>
<div style={{ transform: `translateY(${start * rowHeight}px)` }}>
{visible.map((it, i) => <div key={start + i} style={{ height: rowHeight }}>{render(it, start + i)}</div>)}
</div>
</div>
</div>
);
}
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:不定高怎么定位滚动起点? → 位置缓存数组+二分查找
- 追问2:缓存不准怎么办? → 渲染后实测修正,容忍偏差
- 追问3:聊天从底部开始怎么排? → 反向布局+锚点保持(新消息不跳动)
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:虚拟列表=只渲染可视区:定高纯除法、不定高缓存+二分、动态高度 ResizeObserver 修正。核心难点是不定高与反向布局(聊天场景锚点保持)。
95. Web Worker 实战:什么活该搬进去?
概念 Web Worker 在独立线程执行计算任务,不能访问 DOM,通过 postMessage 通信(结构化克隆传输,大对象有拷贝成本,SharedArrayBuffer 可共享)。适合:大 JSON 解析、加密、图片处理、MD5 分片(见 76)、语法高亮。
典型场景 主线程卡顿的纯计算;上传 hash 计算;本地日志解析。
解决方案 Vite 支持 new Worker(new URL('./x.worker.ts', import.meta.url), { type: 'module' })。
// 文件: worker-client.ts
export function spawn<TIn, TOut>(name: string) {
const worker = new Worker(new URL(`./${name}.worker.ts`, import.meta.url), { type: 'module' });
return {
run(payload: TIn): Promise<TOut> {
return new Promise((resolve, reject) => {
worker.onmessage = (e) => resolve(e.data as TOut);
worker.onerror = (e) => reject(e);
worker.postMessage(payload);
});
},
terminate: () => worker.terminate(),
};
}
// const hasher = spawn<{ file: File }, { hash: string }>('hash'); const { hash } = await hasher.run({ file });
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:postMessage 传 100MB 对象会怎样? → 结构化克隆拷贝耗时;用 Transferable(ArrayBuffer)零拷贝转移
- 追问2:Worker 能用 fetch/DOM 吗? → fetch/network 可以,DOM 不行——纯计算/数据加工才搬
- 追问3:Worker 太多会怎样? → 每个是真线程,内存+调度开销;池化复用(如 workerpool)
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:Worker 管纯计算(hash/解析/图像),不能碰 DOM;通信有克隆成本,大数据用 Transferable。建 Worker 池复用,别每任务新建。
96. 首屏 SSR/SSG/ISR 的选型逻辑?
概念 三种渲染策略一张表看清:SSR 每请求服务端渲染(TTFB 稳、可个性化、服务器贵);SSG 构建期生成(最快,内容静态);ISR 增量静态再生(按时间/按需刷新缓存)。SPA 换 SSR 的动机:LCP、SEO。
典型场景 内容站要 SEO;管理后台无需 SSR;营销页要秒开。
解决方案 内容页 SSG+ISR,动态个性化部分客户端补;后台系统纯 SPA+骨架屏。
// 文件: app/post/[id]/page.tsx (Next.js)
export const revalidate = 300; // ISR: 5 分钟再生
// getPost 为数据层函数(可直接查库/调 API)
export default async function Post({ params }: { params: { id: string } }) {
const post = await getPost(params.id); // 服务端取数, 首屏含内容
return <article>{post.title}</article>;
}
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:SSR 的 TTFB 为什么可能更慢? → 服务端要取数渲染,还占服务器资源
- 追问2:hydration 是什么? → 服务端 HTML + 客户端 JS 重新挂事件的过程,期间点按钮没反应
- 追问3:怎么优化 hydration? → 选择性/渐进水合,islands 架构
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:SSR 换首屏与 SEO、SSG 换极致静态速度、ISR 兼顾新鲜度与速度;后台系统 SPA 足矣。选型先问内容个性化程度与更新频率,再算服务器成本。
97. 资源提示词:preload/prefetch/modulepreload 实战?
概念 资源提示指令告知浏览器加载策略:preload 当前页关键资源(字体/首图/关键 CSS,带 as 和 crossorigin);prefetch 空闲拉下一页可能资源;modulepreload 预取并解析 ESM 依赖图;preconnect 完成连接三件套。
典型场景 LCP 图晚发现;字体 FOUT 闪动;点击进详情想秒开。
解决方案 构建工具自动处理(webpack magic comments / Vite modulePreload),手写只针对构建工具不知道的关键资源(动态 src 的首图)。
<!-- 文件: resource-hints.html -->
<link rel="modulepreload" href="/assets/index.x9k2.js" />
<link rel="prefetch" href="/assets/detail.x9k3.js" /> <!-- 下一页 -->
<link rel="preload" href="/fonts/Inter.var.woff2" as="font" type="font/woff2" crossorigin />
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:preload 和 prefetch 优先级差在哪? → preload 本页必需高优立即拉;prefetch 下一页低优空闲拉
- 追问2:滥用 preload 会怎样? → 和关键资源抢带宽,反而拖慢 LCP——只预载确定必需的
- 追问3:modulepreload 和 preload 差别? → 专管 ES 模块:拉取+解析+依赖图预取,等价于提前执行 import
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:preload 抢救晚发现的必需资源(CSS 里的字体/JS 动态 import),prefetch 榨空闲带宽预载下一页,modulepreload 服务 ES 模块图。按优先级使用,别滥用。
98. 运行时性能:防泄漏的组件清理模式?
概念(见 11/12 的工程化收敛):React 用 useEffect cleanup,Vue 用 onUnmounted;封装成自定义 hook 强制成对调用,把清理责任收进抽象层。
典型场景 代码评审发现基础 setInterval/addEventListener;上线后内存曲线阶梯上涨。
解决方案 所有副作用经统一 hook(返回清理函数);ESLint 规则兜底(exhaustive-deps)。
// 文件: hooks/use-clean-effect.ts (Vue 版)
import { onMounted, onUnmounted } from 'vue';
export function usePolling(fn: () => void, ms = 5000) {
let timer: number | undefined;
onMounted(() => { timer = window.setInterval(fn, ms); });
onUnmounted(() => timer !== undefined && clearInterval(timer));
}
// usePolling(refreshUnread); // 泄漏风险由封装层规避
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:哪些 API 忘清理必漏? → 定时器、事件监听(window/document)、WS、Observer(Intersection/Resize/Mutation)、rAF
- 追问2:闭包引用大对象算泄漏吗? → 算——长生命周期函数持有短生命周期大对象,GC 无法回收
- 追问3:DevTools 怎么定位泄漏? → Memory 面板堆快照对比(三次快照法),Allocation Timeline 看分配轨迹
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:React 清理三件套:effect return cleanup、WS/定时器在 unmount 关、Observer disconnect。规则一句话:谁订阅谁取消,谁创建谁销毁。
99. 性能预算与 CI 门禁?
概念 性能优化最大的敌人是『回退』——预算 = 量化约束(首屏 JS ≤ 200KB gzip、LCP ≤ 2.5s、资源总数 ≤ 50);工具:bundlesize/lighthouse-ci 在 PR 阶段拦截劣化。
典型场景 优化成果反复回退——没人守住;“谁又引入了大依赖”扯皮。
解决方案 LHCI 跑 PR,assert 断言不达标 fail;体积基线存仓库,劣化需显式调预算(留痕)。
// 文件: lighthouserc.json
{
"ci": {
"collect": { "numberOfRuns": 3, "url": ["http://localhost:4173/"] },
"assert": {
"assertions": {
"categories:performance": ["error", { "minScore": 0.9 }],
"largest-contentful-paint": ["error", { "maxNumericValue": 2500 }],
"resource-summary:script:size": ["error", { "maxNumericValue": 200000 }]
}
},
"upload": { "target": "temporary-public-storage" }
}
}
追问预演(面试官顺着答案往深处问,每层接住):
- 追问1:预算定多少合理? → 按现有基线收紧 10-20%,不可达的预算会被绕过而不是遵守
- 追问2:超预算的紧急需求怎么处理? → 显式调预算+留痕(评审),或优化对冲——不能静默突破
- 追问3:LHCI 在 CI 里怎么跑? → 构建→本地起服务→collect 多次采样→assert 断言→报告上传
- 防守要点:追问是逐层深入的——每一层答稳了面试官才会继续;卡住时坦诚说清已知边界比硬编更得分。
总结:性能优化的终点是制度:量化预算(JS 体积/LCP/请求数)+ CI 门禁(LHCI assert)拦截劣化。预算调整显式化,让劣化可见可审。
全 100 题完