稍候片刻,月出文自明。
await 不等于给页面渲染机会,Promise.all 失败也不会取消其他任务。并发要限量,取消要靠支持信号的 API,界面要防止旧响应覆盖新结果。工程上,在边界捕获错误、保留原始原因,留意模块循环依赖及数值和时区陷阱。性能优化先测量,再少做、少分配、少阻塞;必要时把重计算交给 Worker。别把引擎的优化经验当成语言保证。function curry(fn) {
return function curried(...args) {
if (args.length >= fn.length) return fn.apply(this, args);
return (...rest) => curried.apply(this, [...args, ...rest]);
};
}
const add3 = curry((a, b, c) => a + b + c);
add3(1)(2)(3); // 6
add3(1, 2)(3); // 6
// 陷阱:默认值会让 length 变小
function withDefault(a, b = 1, c) {}
withDefault.length; // 1,而不是 3const memoize = (fn) => {
const cache = new Map();
return (arg) => {
if (cache.has(arg)) return cache.get(arg);
const value = fn(arg);
cache.set(arg, value);
return value;
};
};
// 对象参数用 WeakMap:对象被回收后,条目自动消失
const meta = new WeakMap();
function getMeta(el) {
if (!meta.has(el)) meta.set(el, computeMeta(el));
return meta.get(el);
}// 微任务饥饿:页面完全没有机会绘制,标签页看起来像卡死
function starve() {
Promise.resolve().then(starve);
}
starve();const channel = new MessageChannel();
function yieldToMain() {
return new Promise((resolve) => {
channel.port1.onmessage = () => resolve();
channel.port2.postMessage(null);
});
}
async function processInChunks(items, size = 500) {
for (let i = 0; i < items.length; i += size) {
items.slice(i, i + size).forEach(work);
await yieldToMain(); // 浏览器有机会渲染、处理输入
}
}async function f() {
console.log('2'); // 同步执行
await null;
console.log('4'); // 微任务里执行
}
console.log('1');
f();
console.log('3');
// 输出:1 2 3 4async function sleep(ms, signal) {
return new Promise((resolve, reject) => {
if (signal?.aborted) return reject(signal.reason);
const onAbort = () => {
clearTimeout(id);
reject(signal.reason);
};
const id = setTimeout(() => {
signal?.removeEventListener('abort', onAbort); // 正常结束时摘掉监听
resolve();
}, ms);
signal?.addEventListener('abort', onAbort, { once: true });
});
}
const ctrl = new AbortController();
const timer = setTimeout(() => ctrl.abort(new Error('超时')), 1000);
try {
await sleep(5000, ctrl.signal);
} catch (e) {
console.log(e.message); // '超时'
} finally {
clearTimeout(timer);
}let seq = 0;
async function search(q) {
const mine = ++seq;
const res = await fetch(`/api/search?q=${encodeURIComponent(q)}`);
const data = await res.json();
if (mine !== seq) return; // 已有更新的请求,丢弃这次结果
render(data);
}async function* pages(url) {
let next = url;
while (next) {
const res = await fetch(next);
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const page = await res.json();
yield page.items; // 每 yield 一次,消费方拿到一批
next = page.next; // 下一页地址
}
}
for await (const items of pages('/api/list')) {
render(items); // 边取边渲染,不必等全部加载完
}async function* stream(conn) {
try {
for await (const chunk of conn) yield chunk;
} finally {
conn.close(); // break、抛错、提前 return 都会走到这里
}
}try {
await saveOrder(order);
} catch (err) {
throw new Error('下单失败', { cause: err }); // ES2022,保留原始错误
}
class ValidationError extends Error {
constructor(field, message) {
super(message);
this.name = 'ValidationError';
this.field = field;
}
}
new ValidationError('email', '格式不对') instanceof Error; // true// 边界层:把异常收敛成一个显式的值
async function attempt(task) {
try {
return { ok: true, value: await task() };
} catch (error) {
return { ok: false, error };
}
}
const r = await attempt(() => fetchUser(id));
if (!r.ok) toast(r.error.message);const o = {};
o[2] = 'two';
o[1] = 'one';
o.name = 'n';
Object.keys(o); // ['1', '2', 'name']:整数键被重新排序
Object.getOwnPropertySymbols(o); // Symbol 键要单独取
Reflect.ownKeys(o); // 含不可枚举与 Symbol 的全部自有键const money = {
amount: 1999, // 分
[Symbol.toPrimitive](hint) {
if (hint === 'string') return `¥${(this.amount / 100).toFixed(2)}`;
return this.amount / 100; // number 与 default 都返回数值
},
};
`${money}`; // '¥19.99'
+money; // 19.99
money + 1; // 20.99:default 提示,仍按数值处理// config.js
const res = await fetch('/config.json'); // 顶层 await:模块求值期间完成
export const config = await res.json();
// main.js
import { config } from './config.js'; // 会等到上面求值结束
// 按需加载
const { renderChart } = await import('./chart.js');// main.js
const worker = new Worker('/worker.js', { type: 'module' });
const buffer = new ArrayBuffer(1e6);
worker.postMessage({ buffer }, [buffer]); // 第二个参数是转移列表
console.log(buffer.byteLength); // 0:所有权已经转移
worker.onmessage = (e) => console.log(e.data);
// worker.js
self.onmessage = (e) => {
const view = new Uint8Array(e.buffer);
view[0] = 1;
self.postMessage(view.length); // 1000000
};0.1 + 0.2; // 0.30000000000000004
(1.005).toFixed(2); // '1.00'
new Date('2024-01-01').toISOString(); // '2024-01-01T00:00:00.000Z':按 UTC
new Date('2024-01-01T00:00').getHours(); // 0:按本地时间解析
new Date(2024, 0, 1).getMonth(); // 0:月份从 0 开始
const t0 = performance.now();
doWork();
console.log(performance.now() - t0); // 单调,单位毫秒,可能带小数
new Intl.DateTimeFormat('zh-CN', { dateStyle: 'long' }).format(new Date());
// '2024年1月1日'performance.mark('render-start');
renderList(items);
performance.mark('render-end');
performance.measure('render', 'render-start', 'render-end');
new PerformanceObserver((list) => {
for (const entry of list.getEntries()) {
console.log('长任务', entry.duration);
}
}).observe({ type: 'longtask', buffered: true });
基础篇把类型、作用域、this、原型、事件循环按七个问题归过档,进阶篇按「执行模型 → 对象模型 → 异步模型」串了规范细节。这一篇不再重复那些结论,而是往三处再深一层:函数与对象在引擎里到底被怎么处理、异步与并发真正的调度与取消手段、以及真实项目里把代码写稳的那些边界。
适合读者:已经能熟练写业务代码,想补齐「为什么这样写更稳」的理由,或者准备面对面试里那些追问「底层」的环节。文中的代码都能直接粘进浏览器控制台或 Node 里跑,输出都写在注释里。每一条结论我都会标出它属于哪一层——是规范保证的行为,还是引擎的实现细节。
01|三层地图:规范、引擎、宿主
同一个「JavaScript」,其实有三层同时在起作用。分清它们,是高级阶段最省力的一个习惯。
所以遇到「玄学」问题的第一反应应该是:换个宿主还成立吗?成立就是规范行为;不成立就是宿主差异;换了宿主仍然成立、但换个引擎会变,那才是实现细节。举个例子:setTimeout(fn, 0) 在浏览器里嵌套超过五层后最小延迟被抬到 4ms(HTML 规范),在 Node 里最小是 1ms、也没有这条嵌套限制——这是宿主差异;而 Object.keys 一定先按升序排整数索引、再按插入顺序排字符串键,是规范行为,任何引擎都一样。
02|函数:一等公民的两个成本
函数可以传递、返回、存储,高阶写法因此成立;但每创建一个函数对象都有成本:一次分配、可能的环境(闭包)捕获,以及调用点上积累的类型反馈。下面两种写法最常见,也最容易忽略成本。
柯里化与偏应用
柯里化是把多参数函数拆成一串单参数函数,偏应用是固定住部分参数。工具函数常靠 fn.length 判断「还要收几个参数」,但要记住它只统计第一个默认值或剩余参数之前的形参个数。
每一次传参都在新建数组和函数对象。逐帧调用的渲染函数这类热路径上不要用柯里化包装,它更适合初始化阶段的组合,而不是每次调用都重新组装一遍。
记忆化:缓存键决定了它有没有用
记忆化的核心不是「缓存结果」,而是「键能不能唯一标识参数」。原始值可以直接当 Map 的键;对象参数要用 WeakMap,缓存才能跟着对象一起被回收;多参数要么用嵌套 Map,要么序列化成键——后者会遇到键顺序、循环引用和不可序列化值的问题。
用 Map 做缓存必须配上上限(LRU 或定时清理),否则它就是一条缓慢增长的内存泄漏;WeakMap 不会泄漏,但不能遍历、不能计数,只适合「跟着对象走」的关联数据。
03|执行顺序:把「让出主线程」讲准
宏任务 → 清空微任务 → 渲染,这个主干进阶篇已经说过。这里补三件常被说错的事。
想让页面喘息就必须让出到宏任务。await null 做不到,它只是把后续代码放进微任务,仍然在同一轮里跑完;真正插入一个宏任务可以这样做:
上面是简化版:并发调用会互相覆盖 onmessage,真实工具里要维护一个回调队列。Chromium 还提供 scheduler.postTask 与 scheduler.yield;requestIdleCallback 在 Safari 长期没有实现,使用时必须兜底。可移植的写法仍然是 MessageChannel 或 setTimeout。
04|async/await:三个常被误判的点
async 函数总是返回 Promise,await 只是「挂起当前函数,等值可用后从微任务里继续」。把这句话展开,有三个容易误判的地方。
串行与并发的选择也必须显式做:for 里 await 是串行,map 加 Promise.all 才是并发。数量有限制时用小型的 worker 池把游标跑完,而不是一次 Promise.all 几万个请求——Promise.all 失败时也不会取消其余任务,它们照旧在跑。
取消是 Promise 缺的那块。规范没有内置取消,浏览器用 AbortController 达成:fetch 收到 abort 会以 AbortError 拒绝,自己写的异步函数则要主动检查 signal。
abort() 不传参数时,signal.reason 是一个名为 AbortError 的 DOMException;传自定义原因的能力较新,目标环境较老时改成抛一个固定错误更稳。
竞态是异步 UI 里最常见的 bug:先发的请求可能后到,旧结果覆盖新结果。两种解法——用序号丢弃过期响应,或用 AbortController 直接中断旧请求。
05|异步迭代:把流式处理写成 for 循环
异步迭代协议和同步那套几乎一样,只是 next() 返回 Promise<{ value, done }>,键换成 Symbol.asyncIterator。for await...of 同时接受异步可迭代对象和普通可迭代对象,所以数组和异步流可以用同一种写法消费。
两个细节值得记住:async 生成器里的 yield v 会先 await v,所以直接 yield 一个 Promise 也能拿到落定值;循环体抛错或提前 break 时,语言会调用迭代器的 return(),生成器里的 finally 因此有机会关闭连接、释放句柄。
06|错误处理:throw 只是其中一种表达
建议把「边界」和「内部」的约定写清楚:内部用 throw 表达「不该发生」,边界层(UI 事件、路由、请求入口)负责捕获并转成可展示的结果。这样调用方不必到处 try/catch,错误也不会被悄悄吞掉。
07|对象与数组:引擎怎么看你写的字面量
以下是引擎实现细节,不同引擎、不同版本会变。它们能解释「为什么这样写更快」,但不能拿来当语言语义。
实践结论只有一句:热路径上的对象和数组,结构保持稳定;需要频繁增删键的映射关系,直接用 Map——它本来就是为此设计的。
08|Symbol 协议:把自己接进语言的内建行为
自定义可迭代对象时,迭代器方法要返回带 next() 的对象;生成器对象本身既是迭代器又是可迭代对象(它的 [Symbol.iterator]() 返回自己),所以生成器可以直接交给 for...of,不必再包一层。
09|模块:实时绑定、循环依赖与顶层 await
ESM 的导出是活绑定,导入方读到的永远是模块内部当前的值。这条性质带来三个工程后果。
还有两点容易被忘:ESM 默认严格模式,有自己的顶层 this(是 undefined);浏览器里相对路径必须带扩展名,用 file:// 直接打开会被 CORS 拦下,得先起一个本地服务器。
10|并发:把重活搬出主线程
JavaScript 的执行模型是单线程的,但宿主能提供真正的并行。Worker 有独立的全局环境、独立的事件循环,没有 DOM,通信靠 postMessage。
什么时候值得搬:CPU 密集且数据量大(解析大文件、图像处理、加密、复杂排序)。什么时候不值得:需要频繁读写 DOM,或者一次通信的数据比计算本身还贵——克隆是有成本的。
11|数值、时间与本地化:三处精度陷阱
数值。双精度浮点决定了三件事:0.1 + 0.2 !== 0.3;toFixed 是在二进制近似值上舍入的,所以 (1.005).toFixed(2) 得到 '1.00' 而不是 '1.01';金额不该用浮点,换成整数分或十进制库。BigInt 不能与 number 混算(会抛 TypeError),除法是截断的,除以 0n 抛 RangeError,JSON.stringify 遇到它直接抛 TypeError。
时间。Date 内部是毫秒时间戳,getMonth() 从 0 开始,这是最常见的差一错误。字符串解析有两条规则:只有日期的形式('2024-01-01')按 UTC 解析,带时间且没有时区后缀的形式('2024-01-01T00:00')按本地时间解析。跨时区服务里永远显式写时区,或者直接用时间戳。测耗时用 performance.now():它是单调时钟,不受系统时间调整影响,精度被浏览器限制(通常 100 微秒到 1 毫秒)——Date.now() 会跟着系统时钟跳。
本地化。展示交给 Intl.DateTimeFormat 与 Intl.NumberFormat,不要手拼格式;货币、百分号、千分位、复数规则都在里面,手写一份等于把一份不完整的规则表抄进项目。
12|性能:先测量,再改
13|易错点速查
14|小结
把这一篇压缩成三句话:判断问题先分层——是规范、引擎还是宿主在起作用;异步的难点大多不是顺序,而是「谁在等谁」和「怎么取消」;性能的顺序永远是测量、减少工作、减少阻塞,而不是先猜一个瓶颈。
参考资料