ASYNC & EVENT LOOP

让代码学会等待

JavaScript 只有一条主线程,却要同时应付网络、动画与用户输入。它靠的不是多线程,而是一套精密的调度秩序: 调用栈、任务队列、微任务与渲染时机彼此咬合。这一页从事件循环的地基讲起,一路走到 Promise、async/await、 并发池与请求取消,把“异步”从一句口头禅拆成可以推演的机制。

4 个章节 18 个知识点 3 个交互演示 建议阅读 90 分钟
Chapter 01

单线程与事件循环

先弄清楚代码究竟在什么时候执行、什么时候让出主线程,后面所有异步写法都只是这套规则的语法糖。

1.1

为什么需要异步

入门

浏览器给每个页面分配一个主线程,JavaScript 的解释执行、样式计算、布局、绘制、事件回调都挤在这条线程上。 这意味着一旦有代码长时间占用主线程,页面就无法响应点击、无法滚动,甚至无法重绘,用户看到的是整页冻结。 这不是性能问题,而是模型问题:单线程保证了 DOM 操作不会出现并发写入的竞态,代价是必须主动让出执行权。

同步代码是“排队做完再走”:函数调用必须等到返回,读取网络必须等到数据到达。异步则是把等待这件事外包出去—— fetch 把请求交给网络线程,setTimeout 把计时交给浏览器的定时器模块,主线程立刻继续往下执行。 等外部操作有了结果,浏览器再把对应的回调放进队列,等主线程空闲时执行。于是“等待”不再阻塞任何人。

需要区分两个容易混淆的概念:异步不等于多线程。回调函数最终仍在主线程执行,只是执行的时机被推迟了。 真正并行的只有浏览器内部那几个线程(网络、定时器、合成器),JavaScript 代码本身永远是一行一行串行运行的。

同步阻塞与异步让出

// 同步阻塞:主线程被占满,期间点击、滚动、动画全部停摆
function blockMainThread(ms) {
  const start = Date.now();
  // 空转等待,浏览器没有任何机会插入渲染或事件处理
  while (Date.now() - start < ms) { /* busy wait */ }
  console.log('阻塞结束');
}

console.log('A:开始');
blockMainThread(2000);   // 这两秒里页面完全冻结
console.log('B:继续');

// 异步版本:把“等待”交给浏览器的定时器模块
console.log('C:开始');
setTimeout(function () {
  console.log('E:2 秒后由队列调度执行');
}, 2000);
console.log('D:同步代码立刻继续');

// 输出顺序:A → (卡顿 2 秒) → B → C → D → 2 秒后 E
// 注意 E 不是在“第 2 秒那一刻”执行,
// 而是至少 2 秒后、且主线程空闲时才轮到它。

定时器不保证准时。setTimeout(fn, 1000) 的语义是“至少 1000 毫秒后把 fn 排入队列”,而不是“1000 毫秒时一定执行”。如果主线程正被一个长任务占着,回调只能继续等。

1.2

事件循环:调用栈、Web API、任务队列

进阶

事件循环(Event Loop)可以拆成四个角色:调用栈存放正在执行的函数帧;宿主环境(Web API) 负责计时、发请求、监听事件;任务队列按类型分为宏任务队列与微任务队列;事件循环本身是一个永不停止的循环, 不断检查“栈是否为空”,为空就取出下一个任务压栈执行。

关键在于两类任务的优先级不同。每执行完一个宏任务,引擎会把微任务队列彻底清空(清空过程中新产生的微任务也会一并执行), 之后才可能进入渲染阶段,再取下一个宏任务。所以“Promise.then 比 setTimeout 先执行”不是实现细节, 而是规范的执行模型:微任务永远在同一个宏任务末尾被清账。

宏任务包括整段脚本、setTimeout、setInterval、I/O 回调、UI 事件回调; 微任务包括 Promise.then/catch/finally、queueMicrotask、MutationObserver。 注意 async 函数体在 await 之前是同步执行的,await 之后的代码才被包装成微任务续体。

对比项宏任务(Macrotask)微任务(Microtask)
典型来源script 整体、setTimeout、setInterval、I/O、UI 事件Promise.then、queueMicrotask、MutationObserver
执行时机每轮事件循环取一个执行每个宏任务结束后清空整个队列
是否阻塞渲染是,长任务直接掉帧是,微任务死循环会让页面彻底无响应
优先级低高(同轮内先于下一个宏任务与渲染)
常见误区以为 0ms 会立即执行以为 then 是“异步线程”在跑

预测输出顺序

console.log('1:同步开始');

setTimeout(function () {
  console.log('5:宏任务 setTimeout');
}, 0);

Promise.resolve().then(function () {
  console.log('3:微任务 then');
});

(async function () {
  console.log('2:async 函数体,同步执行');
  await null;                       // await 之后进入微任务队列
  console.log('4:await 之后的续体');
})();

queueMicrotask(function () {
  console.log('3.5:queueMicrotask');
});

console.log('2.5:同步结束');

// 实际输出:1 → 2 → 2.5 → 3 → 3.5 → 4 → 5
// 先跑完同步代码,再按入队顺序清空微任务,最后才是 setTimeout
演示 A · 事件循环实时输出可交互

点击按钮,脚本会同时安排同步日志、setTimeout、Promise.then 与 async/await,每一行都在它真正执行的瞬间被追加到下方,因此看到的就是真实顺序。

等待运行……

读顺序题的固定方法:先把所有同步代码走完,途中记录“谁被排进了哪个队列”;然后按入队顺序清空微任务;最后处理下一个宏任务。不要凭感觉猜。

1.3

setTimeout、setInterval 与 requestAnimationFrame

进阶

三个 API 都用于“以后再做”,但归属完全不同的机制。setTimeout 与 setInterval 属于宏任务, 由定时器线程计时后把回调放进队列。requestAnimationFrame(rAF)则绑定在渲染帧上:浏览器在每次重绘前调用它, 回调里拿到的参数是高精度时间戳,天然与屏幕刷新节奏对齐。

最小延迟有两个坑。一是规范允许浏览器对嵌套超过 5 层的定时器施加 4ms 的最小间隔(HTML 标准中的 clamp), 所以 setTimeout(fn, 0) 并不等于“立刻”。二是页面进入后台后,大多数浏览器会把定时器节流到 1 秒甚至更低, 以节省电量——这也是消息轮询在切回标签页时突然“补跑”的原因。此外,setInterval 的间隔从上一次触发开始计算, 一旦回调自身耗时超过间隔,就会出现回调堆积与时间漂移。

动画请一律使用 rAF:它按屏幕刷新率(常见 60Hz,即约 16.7ms 一帧)调度,页面不可见时自动暂停, 并且回调执行时机紧贴渲染,不会出现“改完样式却错过这一帧”的撕裂感。定时器适合逻辑轮询、倒计时这类与渲染无关的任务。

特性setTimeoutsetIntervalrequestAnimationFrame
任务类型宏任务宏任务(可重复)渲染前回调
时间精度毫秒,有 4ms 嵌套下限毫秒,存在累积漂移跟随刷新率,约 16.7ms
后台行为节流至约 1 次/秒同样被节流或暂停自动暂停
适用场景延迟执行、防抖、轮询固定节奏轮询(需谨慎)动画、逐帧布局测量

用递归 setTimeout 代替 setInterval

// 反例:回调耗时 80ms,间隔 100ms,看似没问题;
// 但只要某次耗时 200ms,下一次就会立刻补跑,形成堆积
let count = 0;
const id = setInterval(function () {
  count++;
  // 假设这里有较重的计算
  console.log('tick', count);
  if (count === 3) clearInterval(id);   // 一定要清理,否则永不停止
}, 100);

// 正例:递归 setTimeout,下一次计时从本次结束才开始,
// 天然避免堆积,也能动态调整间隔
function poll(times, done) {
  if (times <= 0) return done();
  const startedAt = performance.now();
  // 这里放真正的任务
  setTimeout(function () {
    const cost = performance.now() - startedAt;
    console.log('第', 4 - times, '次轮询,耗时', Math.round(cost), 'ms');
    poll(times - 1, done);
  }, 100);
}

// rAF:时间戳差值用于“按时间而非按帧”推进动画
let last = 0;
function step(now) {
  if (!last) last = now;
  const delta = now - last;      // 两帧之间的毫秒数,通常是 16 左右
  last = now;
  // 使用 delta 计算位移,掉帧时也不会变慢
  if (delta < 200) requestAnimationFrame(step);
}
requestAnimationFrame(step);

忘记清理定时器是最常见的泄漏源:组件已销毁、页面已切换,回调仍在运行并持有闭包。约定成俗的做法是每个 setTimeout 都配一个 clearTimeout,在卸载钩子里统一清空。

1.4

渲染时机与长任务

深入

60Hz 屏幕每 16.7ms 刷新一次,浏览器要在这一帧内完成:执行宏任务、清空微任务、计算样式、布局、绘制、合成。 任何一步超时,这一帧就被丢弃,用户感知为卡顿。业界把占用主线程超过 50ms 的任务称为长任务(Long Task), 因为 50ms 已超过一帧预算,必然造成可感知的延迟。

解决思路是任务拆分:把上万条数据的处理切成小片,每片处理完主动让出,让浏览器有机会渲染。 可以用 setTimeout(fn, 0) 或 requestIdleCallback 让出,但更精确的方式是配合 rAF: 在帧回调里只做计算,把 DOM 写入推迟,避免在一帧内反复触发样式重算。

另一个高频坑是布局抖动(layout thrashing):在同一轮循环里交替读取 offsetWidth 与写入 style, 每次读取都强制浏览器立即完成一次同步布局。正确做法是“先批量读、再批量写”,或用 rAF 把读写分到不同阶段。

时间切片与读写分离

// 把 50 万次累加切成每片 5ms,片与片之间让出主线程
function processInChunks(total, chunkSize, onDone) {
  let index = 0;
  let sum = 0;
  function work(deadline) {
    // 每片最多占用 5ms,超时就先让出
    const sliceEnd = performance.now() + 5;
    while (index < total && performance.now() < sliceEnd) {
      sum += Math.sqrt(index++);
    }
    if (index < total) {
      // 优先用空闲回调;不支持时退回 setTimeout
      if (typeof requestIdleCallback === 'function') {
        requestIdleCallback(work);
      } else {
        setTimeout(work, 0);
      }
    } else {
      onDone(sum);
    }
  }
  work();
}

// 反例:循环里读一次、写一次,强制同步布局
const items = document.querySelectorAll('.topic');
for (const item of items) {
  const h = item.offsetHeight;          // 读 → 强制布局
  item.style.height = h + 10 + 'px';    // 写 → 使布局失效
}

// 正例:先读后写,一轮只触发一次布局
const heights = Array.from(items, (el) => el.offsetHeight);
items.forEach((el, i) => {
  el.style.height = heights[i] + 10 + 'px';
});

现代浏览器提供了 PerformanceObserver 与 longtask 条目类型,可以真实测量长任务;scheduler.postTask() 还支持为任务设置优先级。调试卡顿时先测,再改,比凭直觉加 setTimeout 可靠得多。

Chapter 02

Promise 的秩序

Promise 不是“更优雅的回调”,而是一个对异步结果建模的状态机。理解状态与值传递,才能写出可推理的异步链。

2.1

回调地狱与 Promise 的诞生

入门

早期异步靠回调传递结果:请求成功调用 success,失败调用 error。单个回调并不难写, 难的是依赖关系——第二步请求依赖第一步的返回值,第三步又依赖第二步。层层嵌套之后, 代码向右生长成金字塔,错误处理分散在每一层,无法用一次 try/catch 兜住。

回调模式还有三个结构性缺陷:一是控制反转,你把回调交给第三方库,无法保证它只调用一次、不会同步调用、不会吞掉异常; 二是无法组合,两个并行请求的结果要自己维护计数器;三是无法表达“失败会沿着链向后传播”的语义, 每一层都得手写判空与错误分支。

Promise 把“未来的值”抽象成对象:调用方拿到的是一个占位符,可以继续 .then 出新的占位符, 依赖关系被拉平成一条链。错误通过 catch 在链尾统一接住,控制权回到调用方手里。

从嵌套回调到链式调用

// 回调版本:三层依赖,错误分支散落各处
getUser('u1', function (err, user) {
  if (err) return handle(err);
  getOrders(user.id, function (err2, orders) {
    if (err2) return handle(err2);
    getDetail(orders[0].id, function (err3, detail) {
      if (err3) return handle(err3);
      render(detail);            // 缩进越来越深,逻辑被淹没
    });
  });
});

// Promise 版本:依赖关系被拉平成一条链
getUser('u1')
  .then(function (user) {
    return getOrders(user.id);   // 返回值会被自动展开
  })
  .then(function (orders) {
    return getDetail(orders[0].id);
  })
  .then(function (detail) {
    render(detail);
  })
  .catch(function (err) {
    handle(err);                 // 任何一环失败都流入这里
  });

// 并行版本:不再需要手动维护计数器
Promise.all([getProfile(), getNotices()])
  .then(function (result) {
    render(result[0], result[1]);
  });

回调并没有消失,它只是被封装进 then 内部。Promise 真正带来的变化是:结果对象可以被传递、组合、复用,错误处理可以集中,而不再依赖调用者的自觉。

2.2

三种状态与 then / catch / finally

进阶

一个 Promise 只有三种状态:pending(等待)、fulfilled(成功,携带一个值)、 rejected(失败,携带一个原因)。状态只能从 pending 单向迁移到另外两者之一, 一旦落定就不可逆,后续的 resolve 或 reject 调用会被静默忽略。 这条“不可逆”规则是 Promise 可推理的基础:一个结果只会产生一次。

then(onFulfilled, onRejected) 注册回调,catch 等价于 then(null, onRejected), finally 不接收值也不改变结果,只做清理(关闭 loading、释放锁)。 真正的坑在于“错误穿透”:链上任意一环抛错或返回 rejected 的 Promise,都会跳过中间的 then 成功回调, 直接找到最近的 onRejected。这也解释了为什么推荐把 catch 放在链尾。

另一个细节:then 中的回调永远不会同步执行。即使 Promise 已经是 fulfilled 状态, 回调也会被放入微任务队列,等到当前同步代码结束才运行。这保证了执行顺序的一致性,也意味着不能依赖 then 立刻改变外部变量。

状态迁移与清理

const p = new Promise(function (resolve, reject) {
  // 同步执行器(executor)会立即运行
  console.log('1:executor 同步执行');
  Math.random() > 0.5 ? resolve('成功值') : reject(new Error('失败原因'));
});

p.then(function (value) {
  console.log('3:成功', value);
  return value + '!';
}).catch(function (err) {
  console.log('3:失败', err.message);
}).finally(function () {
  // 不论成功失败都会执行,且不透传、不改变结果
  console.log('4:无论成败都会清理 loading');
});

console.log('2:同步代码先走完');

// 状态不可逆:第二个 resolve 会被忽略
new Promise(function (resolve) {
  resolve('第一次');
  resolve('第二次');       // 无效
  throw new Error('也无效'); // 已落定后抛错只会变成未捕获异常
}).then(function (v) { console.log(v); }); // 第一次

// 错误穿透:跳过中间的 then,直到遇到捕获分支
Promise.resolve('ok')
  .then(function (v) { throw new Error('链中抛错'); })
  .then(function () { console.log('不会执行'); })
  .catch(function (e) { console.log('在链尾接住:', e.message); });

promise.then(fn) 里如果 fn 内部抛错,错误不会同步冒泡,而是变成返回的新 Promise 的 rejected 原因。因此只写 then 不写 catch,异常就会彻底沉默——浏览器会报 unhandled rejection,但业务逻辑已经中断。

2.3

链式调用与值 / 错误传递

进阶

每次调用 .then() 都会返回一个全新的 Promise,这是链式调用成立的原因。 新 Promise 的命运由回调的返回值决定:返回普通值则以该值 fulfilled;返回 Promise 则先展开它, 跟随它的状态与值;抛出异常则 rejected。这种“自动展开”让嵌套的异步调用可以被扁平化书写。

与之相对的是值穿透:如果 then 的第一个参数不是函数(例如传了 null 或忘记写), 当前值会原样传给下一个 then。错误同样会沿着链向后穿透,直到遇到能处理它的 onRejected。 这带来一个实用技巧:链中间的 then 可以只处理成功分支,错误留给末尾统一收口。

需要警惕的是,回调里如果返回了另一个链的 Promise 但忘记 return,链会立刻继续, 后续 then 拿到的是 undefined,而真正的工作还在后台跑。这类 bug 不会报错,只表现为“数据偶尔是空的”。

返回值如何决定下一环

Promise.resolve(1)
  .then(function (v) {
    return v + 1;                 // 普通值 → 下一环收到 2
  })
  .then(function (v) {
    return new Promise(function (resolve) {
      setTimeout(function () { resolve(v * 10); }, 100);
    });                           // 返回 Promise → 等它落定,得到 20
  })
  .then(null)                     // 非函数 → 值穿透,仍为 20
  .then(function (v) {
    console.log('最终值', v);       // 20
    throw new Error('这里出错');
  })
  .then(function () {
    console.log('被跳过');          // 错误穿透,不执行
  })
  .catch(function (err) {
    console.log('接住', err.message);
    return '恢复值';                // catch 也能恢复链,后续继续走成功分支
  })
  .then(function (v) {
    console.log('恢复后继续', v);
  });

// 常见错误:忘记 return,链不会等待
function loadWrong() {
  Promise.resolve('数据').then(function (v) {
    // 没有 return
  });
}
// 正确写法
function loadRight() {
  return Promise.resolve('数据').then(function (v) { return v; });
}

判断链的正确性有个笨办法:把每个 then 的返回值写在心里,逐环推演。凡是“下一环拿到的值”和预期不符,先检查是否漏了 return。

2.4

组合方法:all、allSettled、race、any

深入

单个 Promise 描述“一件事”,组合方法描述“一组事”的完成语义。四个 API 的差别只在成功与失败的定义上: all 要求全部成功,任意一个失败就立刻失败;allSettled 永不失败,等全部落定后返回状态清单; race 取第一个落定的(无论成败);any 取第一个成功的,全部失败才失败。

选型取决于业务对“部分失败”的容忍度。首屏必须数据一致时用 all;批量任务、需要逐个汇报结果时用 allSettled; 超时控制、多源竞速用 race;多 CDN / 多镜像取最快可用结果用 any。 注意 any 的失败原因是 AggregateError,其 errors 数组按输入顺序保存每个失败原因。

两个容易忽略的细节:传入空数组时,all 与 allSettled 立即成功(结果为空数组), 而 race 与 any 会永远 pending,因为没有任何 Promise 能落定。 另外,all 在某个任务失败后不会取消其余任务,它们仍在后台执行,只是结果被丢弃——需要真正取消请配合 AbortController。

方法成功条件失败条件返回值典型场景
Promise.all全部 fulfilled任意一个 rejected(立即)按输入顺序排列的值数组页面初始化所需的多个接口
Promise.allSettled全部落定不会失败{status, value/reason} 数组批量上传、逐条汇报
Promise.race第一个 fulfilled第一个 rejected第一个落定者的值或原因超时控制、竞速
Promise.any第一个 fulfilled全部 rejected第一个成功的值多镜像容灾
// 模拟三个耗时不同的任务
function task(name, ms, shouldFail) {
  return new Promise(function (resolve, reject) {
    setTimeout(function () {
      shouldFail ? reject(new Error(name + ' 失败')) : resolve(name + ' 完成');
    }, ms);
  });
}

const jobs = [task('A', 400, false), task('B', 900, false), task('C', 600, true)];

Promise.all(jobs)
  .then(function (list) { console.log('全部成功', list); })
  .catch(function (err) { console.log('all 提前失败:', err.message); });

Promise.allSettled(jobs).then(function (list) {
  // 永远走这里,逐个判断 status
  list.forEach(function (item) {
    console.log(item.status, item.value || item.reason.message);
  });
});

Promise.race(jobs)
  .then(function (v) { console.log('race 先落定的是成功:', v); })
  .catch(function (e) { console.log('race 也可能先失败:', e.message); });

Promise.any([task('镜像1', 300, true), task('镜像2', 500, false)])
  .then(function (v) { console.log('any 取最快成功:', v); });

// 空数组的边界
Promise.all([]).then(function (v) { console.log('all 空数组立即成功', v); });
Promise.allSettled([]).then(function (v) { console.log('allSettled 空数组', v); });
// Promise.race([]) 与 Promise.any([]) 会一直 pending,慎用
演示 B · 组合方法对比模拟延时

三个模拟任务:A 在 400ms 后成功,B 在 900ms 后成功,C 在 600ms 后失败。切换组合方法执行, 观察回调在什么时刻触发、拿到的是值还是错误。本演示不发起任何真实请求。

选择一种组合方法后点击执行。

Promise.all 失败后其余 Promise 的 rejection 若无人处理,同样会触发 unhandled rejection 警告。批量场景下先给每个 promise 挂一个空 catch,或直接改用 allSettled。

2.5

手写一个简化版 Promise

高阶

自己实现一遍,是理解 Promise 最快的路。需要抓住四个要点:构造时立即执行 executor 并注入 resolve/reject; 用 state 与 value 保存状态,落定后不再改变;then 在 pending 时把回调存进队列, 已落定时则异步调度;then 必须返回新的 Promise,并用回调的返回值来落定它。

真实实现还要处理更多细节:回调必须异步执行(用微任务)、返回值若是 Promise 需要递归展开、thenable 的兼容、 自引用检测(then 返回自身会死循环)。下面的版本刻意省略了 thenable 展开,只为把主干讲清楚; 生产环境请直接用原生 Promise。

状态机与回调队列

class TinyPromise {
  constructor(executor) {
    this.state = 'pending';       // pending | fulfilled | rejected
    this.value = undefined;
    this.handlers = [];           // 暂存 then 注册的回调与下游的 resolve/reject
    const resolve = (v) => this.settle('fulfilled', v);
    const reject = (e) => this.settle('rejected', e);
    try {
      executor(resolve, reject);  // 同步执行,异常自动转为 rejected
    } catch (err) {
      reject(err);
    }
  }
  settle(state, value) {
    if (this.state !== 'pending') return;   // 状态不可逆
    this.state = state;
    this.value = value;
    queueMicrotask(() => {                  // 统一异步清账
      this.handlers.forEach((h) => this.run(h));
      this.handlers = [];
    });
  }
  run(handler) {
    const cb = this.state === 'fulfilled' ? handler.onFulfilled : handler.onRejected;
    if (typeof cb !== 'function') {
      // 值穿透 / 错误穿透:直接把当前结果交给下游
      this.state === 'fulfilled' ? handler.resolve(this.value) : handler.reject(this.value);
      return;
    }
    try {
      handler.resolve(cb(this.value));      // 返回值决定下游状态
    } catch (err) {
      handler.reject(err);
    }
  }
  then(onFulfilled, onRejected) {
    return new TinyPromise((resolve, reject) => {
      const handler = { onFulfilled, onRejected, resolve, reject };
      if (this.state === 'pending') this.handlers.push(handler);
      else queueMicrotask(() => this.run(handler));
    });
  }
  catch(onRejected) { return this.then(null, onRejected); }
}

把 queueMicrotask 换成同步调用,你会发现链式顺序立刻错乱——这正说明原生 Promise 的“异步保证”不是可选项,而是链式语义的一部分。

2.6

Promisify 与统一错误处理

深入

老 API 大多遵循 Node 的 error-first 回调:第一个参数是错误对象,第二个才是数据。promisify 就是把这层约定 包装成 Promise,让调用方可以用统一的 then/catch 处理。前提是回调必须只调用一次, 并且遵循 (err, data) 的顺序,否则包装之后会出现“成功后又被 reject”的错乱。

统一错误处理的目标是:所有异常在同一个地方被归一化为可读的错误对象,并决定是提示用户、上报监控还是静默重试。 常见做法是在请求层抛出自定义错误(带 code、status),业务层只关心 message, 最外层用一个全局兜底记录未处理的 rejection。

另一个思路是 Result 风格:把 { ok, data, error } 作为正常返回值,而不是抛异常。 它适合“失败是常态”的场景(如表单校验、可预期的业务拒绝),能避免 try/catch 层层包裹; 但不要在同一项目里混用两套风格,否则调用方永远猜不到该不该 catch。

包装回调与归一化错误

// 1. promisify:只适用于 error-first 回调
function promisify(fn) {
  return function () {
    const args = Array.prototype.slice.call(arguments);
    return new Promise(function (resolve, reject) {
      fn.apply(this, args.concat(function (err, data) {
        err ? reject(err) : resolve(data);
      }));
    });
  };
}
// 2. 自定义错误 + 统一请求层
class ApiError extends Error {
  constructor(message, status, code) {
    super(message);
    this.name = 'ApiError';
    this.status = status;
    this.code = code;
  }
}
function request(url, options) {
  return fetch(url, options).then(function (res) {
    if (!res.ok) {
      throw new ApiError('请求失败:' + res.status, res.status, 'HTTP_' + res.status);
    }
    return res.json();
  }).catch(function (err) {
    // 网络层错误没有 status,补一个统一标识
    if (!(err instanceof ApiError)) {
      throw new ApiError(err.message || '网络异常', 0, 'NETWORK');
    }
    throw err;
  });
}
// 3. Result 风格:失败也是正常返回值
function safeRequest(url) {
  return request(url).then(
    function (data) { return { ok: true, data: data }; },
    function (error) { return { ok: false, error: error }; }
  );
}
// 4. 全局兜底:记录真正被遗漏的 rejection
window.addEventListener('unhandledrejection', function (event) {
  console.error('未处理的 rejection:', event.reason);
});

错误对象要保留原始堆栈与业务码,不要只 throw new Error('出错了')。日志里没有 status 与 code,线上排查会变成猜谜。

Chapter 03

async / await

语法糖的价值在于把“链”写成“顺序”,但它没有改变事件循环。知道每个 await 前后发生了什么,才不会被表面的同步假象骗到。

3.1

语法与执行顺序

进阶

async 函数总是返回一个 Promise:返回普通值会被包装成 fulfilled,抛出异常则变成 rejected。 await 会暂停当前函数的执行,等待右侧表达式落定,然后把后续代码作为微任务恢复。 注意暂停的只是这个函数,调用方与主线程都不受影响。

因此“await 之后是同步的”是错觉。从调用方视角看,await 之后的代码一定在当前同步代码全部执行完之后才运行, 且注册顺序早于 setTimeout。另一处细节:await 对非 Promise 值也会让出一次(规范会做一次微任务跳转), 所以 await 1 同样会产生异步间隙。

最常见的误用是在 forEach 里写 await:forEach 不等待回调返回的 Promise, 循环会瞬间跑完,所有任务并发启动,而外层函数在它们完成前就继续了。需要顺序执行请用 for...of, 需要并行请显式收集 Promise 再 Promise.all。

then 与 await 的等价改写

function delay(ms, value) {
  return new Promise(function (resolve) {
    setTimeout(function () { resolve(value); }, ms);
  });
}

// async 函数内部:await 之前同步,之后进入微任务
async function run() {
  console.log('1:函数体内,同步');
  const a = await delay(100, 'A');
  console.log('3:拿到', a);       // 后续代码被挂起,等 Promise 落定
  return a + '!';
}
console.log('2:调用后立即继续');
run().then(function (v) { console.log('4:返回值', v); });

// 等价的 then 写法,便于对照理解
function runThen() {
  console.log('1:函数体内,同步');
  return delay(100, 'A').then(function (a) {
    console.log('3:拿到', a);
    return a + '!';
  });
}

// 反例:forEach 不会等待
async function wrong(list) {
  list.forEach(async function (id) {
    await delay(50);
    console.log('完成', id);   // 顺序不可控,外层也无法等待
  });
  console.log('外层先结束');    // 这句先于所有“完成”打印
}

// 正例:顺序执行
async function right(list) {
  for (const id of list) {
    await delay(50);
    console.log('完成', id);   // 严格按顺序,逐个等待
  }
}

顶层的 await 只在 ES Module 中可用(<script type="module">)。传统脚本想用,得包一层 async 自执行函数,或使用顶层 await 的模块入口。

3.2

串行、并行与并发控制

深入

串行与并行不是风格偏好,而是时间成本的选择。四个各耗时 400ms 的请求,串行需要约 1600ms,并行只需约 400ms。 但并行并非越多越好:浏览器对同域 HTTP/1.1 连接数有限制,服务端也有承载上限,一次性发出上百个请求只会让它们互相排队, 还可能触发限流。于是需要并发池:同时最多跑 N 个,完成一个就补一个。

串行适合“后一步依赖前一步结果”的链式场景,用 for...of 加 await 最直观; 并行适合彼此独立的任务,用 Promise.all;有上限的并行则通过维护一个运行中的任务集合与一个索引指针来实现。 注意 map(async fn) 得到的是 Promise 数组,必须再 await Promise.all,否则你只是启动了一堆没人管的任务。

并发池:限流但不牺牲总时长

// 并发池:最多同时运行 limit 个任务,返回结果顺序与输入一致
async function pool(tasks, limit) {
  const results = new Array(tasks.length);
  let cursor = 0;                       // 下一个待取任务的下标

  async function worker() {
    while (cursor < tasks.length) {
      const index = cursor++;           // 先取下标,再自增,避免重复
      try {
        results[index] = await tasks[index]();
      } catch (err) {
        results[index] = { error: err }; // 单个失败不影响整池
      }
    }
  }

  // 启动 limit 个 worker,它们共享同一个 cursor
  const runners = [];
  for (let i = 0; i < Math.min(limit, tasks.length); i++) {
    runners.push(worker());
  }
  await Promise.all(runners);
  return results;
}

// 用法:10 个任务,最多 3 个同时进行
const tasks = Array.from({ length: 10 }, (_, i) => () =>
  new Promise(function (resolve) {
    setTimeout(function () { resolve('任务 ' + i); }, 200);
  })
);
pool(tasks, 3).then(function (list) { console.log(list); });
演示 C · 串行与并行耗时模拟任务

四个模拟任务,每个固定耗时 400ms(用定时器模拟,不发起真实请求)。分别以串行与并行方式执行, 对比总耗时。串行约 1600ms,并行约 400ms。

选择一种执行方式开始计时。

并发池的 cursor++ 必须在 await 之前完成取值。如果写成 await tasks[cursor++]() 之外的异步间隙后再读下标,多个 worker 会取到同一个任务。

3.3

try / catch 与错误处理

进阶

await 的最大便利是让异步错误重新变成可以用 try/catch 捕获的异常。 被 await 的 Promise 若变成 rejected,会在此处以抛出异常的形式出现,捕获后函数可以继续执行。 这也是 async/await 相比裸 Promise 链最实际的优势:错误处理与同步代码写法一致。

但要小心两个“吞错”陷阱。一是在 catch 里只写一行 console.log,既不影响返回值也不重新抛出, 调用方会以为一切正常;二是并行任务中只 await 了部分 Promise,其余失败会成为 unhandled rejection。 正确做法是:能恢复就返回降级值,不能恢复就包装后重新抛出,让上层决定如何提示。

finally 适合做与成败无关的清理:关闭 loading、释放锁、断开连接。注意 return 写在 try 里时, finally 仍会执行;如果 finally 里也有 return,它会覆盖前面的返回值——这是容易忽略的语义。

分层捕获与重新抛出

async function loadProfile(id, signal) {
  try {
    const res = await fetch('/api/profile/' + id, { signal: signal });
    if (!res.ok) throw new Error('HTTP ' + res.status);
    return await res.json();
  } catch (err) {
    // 取消导致的错误不是业务失败,单独识别后继续抛
    if (err.name === 'AbortError') throw err;
    // 可恢复的失败:返回降级值,但要留下可观测的痕迹
    console.warn('读取资料失败,使用缓存', err.message);
    const cached = localStorage.getItem('profile-' + id);
    if (cached) return JSON.parse(cached);
    // 不可恢复:包装后抛出,保留原始原因
    const wrapped = new Error('资料加载失败');
    wrapped.cause = err;
    throw wrapped;
  } finally {
    // 无论成功、失败还是取消都会执行
    document.body.classList.remove('is-loading');
  }
}

// 并行任务:每个都挂 catch,避免遗漏
async function loadDashboard(ids) {
  const settled = await Promise.all(
    ids.map(function (id) {
      return loadProfile(id).catch(function (err) {
        return { id: id, error: err.message };   // 把失败转成数据
      });
    })
  );
  return settled;
}

// 反例:catch 之后什么都不做,调用方拿到 undefined
async function swallow() {
  try {
    await Promise.reject(new Error('真实错误'));
  } catch (e) {
    // 什么都不做 → 错误彻底消失
  }
}

ES2022 起 Error 支持 cause 选项,可用于保留原始错误链:throw new Error('上层语义', { cause: err })。排查线上问题时,比拼接字符串更可靠。

3.4

AbortController 与请求取消

深入

Promise 一旦创建就无法从外部终止,这正是“竞态导致旧数据覆盖新数据”的根源。浏览器给出的方案是 AbortController: 它持有一个 signal,调用 abort() 后 signal 变为 aborted 状态, 所有监听该 signal 的异步操作(如 fetch)会被终止,并抛出名为 AbortError 的异常。

取消是协作式的:API 必须主动检查 signal,否则什么也不会发生。所以自定义的异步流程要把 signal 一路透传, 并在每个可中断点检查 signal.aborted。同时记得监听 abort 事件做资源清理(清除定时器、移除监听), 否则“取消”只是让结果被丢弃,后台工作仍在继续。

实践中最典型的场景是搜索联想:每次输入都发起请求,新请求发出前先 abort 掉上一个, 保证只有最后一次结果被渲染。超时也可以用 AbortSignal.timeout(ms) 一行实现,但它与手动取消的 signal 需要用 AbortSignal.any([...]) 合并。

可取消的请求与清理

let current = null;              // 保存当前请求的 controller

async function search(keyword) {
  // 取消上一次仍在进行的请求,避免旧结果覆盖新结果
  if (current) current.abort();
  const controller = new AbortController();
  current = controller;

  const timer = setTimeout(function () {
    controller.abort(new Error('请求超时'));   // 可携带自定义原因
  }, 5000);

  try {
    const res = await fetch('/api/search?q=' + encodeURIComponent(keyword), {
      signal: controller.signal
    });
    if (!res.ok) throw new Error('HTTP ' + res.status);
    return await res.json();
  } catch (err) {
    if (err.name === 'AbortError') {
      // 主动取消属于预期行为,不要当作错误提示给用户
      console.log('已取消:', controller.signal.reason);
      return null;
    }
    throw err;
  } finally {
    clearTimeout(timer);          // 无论成败都要清掉计时器
    if (current === controller) current = null;
  }
}

// 组合多个取消源:手动取消 + 8 秒超时
const manual = new AbortController();
const signal = AbortSignal.any([manual.signal, AbortSignal.timeout(8000)]);

manual.signal.addEventListener('abort', function () {
  console.log('用户主动取消');
});

fetch('/api/report', { signal: signal }).catch(function (err) {
  console.log(err.name);          // 取消或超时都会得到 AbortError
});

取消后不要立刻把 UI 切到“失败”状态。用户主动取消、组件卸载触发的 abort 都是预期内的,应当静默处理;只有真正的网络错误才需要提示。

Chapter 04

网络与异步实战

把前四章的知识落到真实场景:如何读 Response、如何加超时与重试、如何限流,以及哪些错误会在沉默中发生。

4.1

fetch 与 Response

进阶

fetch 返回的 Promise 在收到响应头时就会 fulfilled,而不是等响应体下载完。 因此它只在网络层失败(断网、DNS 错误、被拦截)时 reject;HTTP 404、500 都属于“成功的响应”, 必须自己检查 response.ok(状态码 200–299)或 response.status。

响应体是一次性流,只能读取一次。根据内容类型选择 json()、text()、blob() 或 arrayBuffer(),它们都返回 Promise,因为读取过程本身是异步的。响应头通过 response.headers.get() 读取, 但受同源策略限制,跨域时只能访问 CORS 白名单内的头。

默认的 fetch 没有超时。一个挂起的请求可能让 loading 永远转下去,必须用 AbortSignal.timeout(ms) 或手动 AbortController 兜住。另外默认不发送跨域 Cookie, 需要显式设置 credentials: 'include',且服务端必须返回对应的 CORS 头。

读取状态、头与响应体

async function fetchJSON(url) {
  const res = await fetch(url, {
    method: 'GET',
    headers: { 'Accept': 'application/json' },
    credentials: 'same-origin'          // 同源携带 Cookie,跨域需 include
  });

  // fetch 不会因为 4xx / 5xx 而 reject,必须手动判断
  if (!res.ok) {
    // 错误响应也可能带 JSON 说明,尽量读出来
    let detail = '';
    try {
      const body = await res.json();
      detail = body.message || '';
    } catch (e) {
      detail = await res.text();        // 注意:body 已被读过就不能再读
    }
    throw new Error('HTTP ' + res.status + ' ' + detail);
  }

  // 读取内容类型,决定解析方式
  const type = res.headers.get('content-type') || '';
  if (type.includes('application/json')) return res.json();
  if (type.startsWith('text/')) return res.text();
  return res.blob();                    // 图片、文件下载

  // 其他常用头:res.headers.get('cache-control')
  // 重定向后的最终地址:res.url;是否被重定向:res.redirected
}

// 注意:下面这段会抛出解析错误,因为 body 只能消费一次
const r = await fetch('/api/list');
// await r.json();
// await r.text();   // TypeError: body stream already read

response.body 是一个 ReadableStream,可用于流式读取大文件并显示进度;配合 TextDecoderStream 还能逐块解析。数据量大时,比等 json() 一次性解析更省内存。

4.2

超时、重试与指数退避

深入

超时的实现方式有两种:用 Promise.race 让请求与一个定时器赛跑,或者在 fetch 上挂 AbortSignal.timeout()。前者的问题是不会真正取消请求,后台仍在传输;后者会中断连接、释放资源,是更正确的做法。

重试不是无脑循环。先判断错误是否可重试:网络错误、502/503/504、429 通常可以重试; 400、401、403、404 重试多少次都无意义。其次要控制节奏,采用指数退避(1s、2s、4s……)并加入随机抖动, 避免大量客户端在同一时刻重新打满服务端。

还需要设置上限:最大重试次数、单次超时、总耗时预算。如果请求不是幂等的(例如创建订单的 POST), 盲目重试可能造成重复写入,必须由服务端幂等键配合,或干脆不重试。

带退避的重试封装

function sleep(ms) {
  return new Promise(function (resolve) { setTimeout(resolve, ms); });
}

// 单次请求:超时 + 统一错误
async function fetchOnce(url, timeout) {
  const signal = AbortSignal.timeout(timeout);   // 到点自动 abort
  const res = await fetch(url, { signal: signal });
  if (!res.ok) {
    const err = new Error('HTTP ' + res.status);
    err.status = res.status;
    throw err;
  }
  return res.json();
}

// 哪些错误值得重试:网络错误 / 429 / 5xx
function isRetryable(err) {
  if (err.name === 'TimeoutError' || err.name === 'TypeError') return true;
  if (err.status === 429) return true;
  return typeof err.status === 'number' && err.status >= 500;
}

async function fetchWithRetry(url, options) {
  const opts = Object.assign({ retries: 3, timeout: 4000, base: 500 }, options);
  let lastError = null;

  for (let attempt = 0; attempt <= opts.retries; attempt++) {
    try {
      return await fetchOnce(url, opts.timeout);
    } catch (err) {
      lastError = err;
      if (attempt === opts.retries || !isRetryable(err)) break;
      // 指数退避 + 0~300ms 抖动,避免同时重试
      const wait = opts.base * Math.pow(2, attempt) + Math.random() * 300;
      console.warn('第', attempt + 1, '次失败,', Math.round(wait), 'ms 后重试');
      await sleep(wait);
    }
  }
  throw lastError;
}

// 注意:非幂等请求(POST 创建资源)不要直接套用重试
fetchWithRetry('/api/list', { retries: 2, timeout: 3000 });

AbortSignal.timeout 抛出的错误名是 TimeoutError,而手动 abort() 抛出的是 AbortError。判断重试时要把两者区分开,否则用户主动取消也会触发重试。

4.3

并发请求池实现

高阶

请求池要同时满足三个约束:限流(同时最多 N 个)、顺序(结果按输入顺序返回,而不是完成顺序)、 隔离(单个失败不拖垮整批)。实现骨架与 3.2 的并发池一致,差别在于任务本身是网络请求, 需要额外的超时、错误包装与可选的整批取消。

为什么不直接用 Promise.all 分批(每 N 个一组)?因为分批是“等最慢的那个”再进下一批, 存在木桶效应;而共享游标的池子在任一任务完成后立刻补位,总耗时更接近理论最优。

结果顺序用下标写入保证:每个任务启动前先固定自己的 index,完成后写入 results[index]。 切勿用 push,否则拿到的是完成顺序,与输入错位。

限流请求池

async function fetchPool(urls, limit, timeout) {
  const results = new Array(urls.length);
  let cursor = 0;
  const controller = new AbortController();

  async function worker() {
    while (cursor < urls.length) {
      const index = cursor++;
      const url = urls[index];
      try {
        const res = await fetch(url, {
          signal: AbortSignal.any([controller.signal, AbortSignal.timeout(timeout)])
        });
        if (!res.ok) throw new Error('HTTP ' + res.status);
        results[index] = { ok: true, data: await res.json() };
      } catch (err) {
        // 失败写入占位,保持数组长度与顺序
        results[index] = { ok: false, error: err.message, url: url };
        // 若错误是致命的鉴权失败,可中止整批
        if (err.status === 401) controller.abort();
      }
    }
  }

  const size = Math.min(limit, urls.length);
  const workers = Array.from({ length: size }, function () { return worker(); });
  await Promise.all(workers);
  return results;             // 顺序与 urls 完全一致
}

// 用法:12 个地址,最多 4 个并发,每个 5 秒超时
const urls = Array.from({ length: 12 }, function (_, i) {
  return '/api/item/' + (i + 1);
});
fetchPool(urls, 4, 5000).then(function (list) {
  const failed = list.filter(function (item) { return !item.ok; });
  console.log('成功', list.length - failed.length, '失败', failed.length);
});

若需要对整批请求做“超时后统一取消”,把共享的 controller 暴露给调用方,并在外部定时器中调用 abort()。注意 abort 后 worker 的 while 循环仍会继续取任务,应在循环条件里加 && !controller.signal.aborted。

4.4

串行、并行、竞速的选型与常见坑

进阶

选型可以归结为一句话:有依赖就串行,无依赖就并行,只关心最快结果就竞速。 但真实业务常常混合:先用串行拿到 token,再并行拉取多个列表,其中某个列表允许降级;某个搜索建议则用竞速取最快的镜像。 把每个请求当成一个有状态的单元,画清依赖箭头,选型自然浮现。

最常见的坑是未处理的 rejection。并行发起多个请求却只 await 了一个,或者 Promise.race 结束后 输掉的那些 Promise 失败无人接管,都会在控制台留下 unhandled rejection。第二个坑是竞态覆盖: 快速切换筛选条件时,先发的请求后返回,把新数据覆盖成旧数据——需要请求序号或 AbortController 守卫。

第三类坑是资源泄漏:组件卸载后回调仍在 setState、定时器未清、事件监听未解绑、响应体未读取导致连接无法复用。 在单页应用里,这类问题会随着路由切换不断累积,最终表现为页面越用越卡。约定“谁创建,谁销毁”,并把清理写进 finally。

场景推荐方式原因配套措施
后一步依赖前一步结果for...of + await顺序明确,错误可中断try/catch 包裹循环体
多个独立接口拼首屏Promise.all总耗时取最慢者单个 catch 转降级值
批量任务需逐条结果Promise.allSettled不会因一条失败而中断渲染部分成功状态
搜索联想、多镜像AbortController / race只保留最新或最快结果旧请求必须 abort
大量请求(>10)并发池避免打满连接与限流固定下标写入结果
// 竞态守卫:只允许最后一次请求的结果落地
let seq = 0;
async function loadList(keyword) {
  const mySeq = ++seq;                 // 每次调用生成新序号
  const data = await fetch('/api/list?q=' + encodeURIComponent(keyword))
    .then(function (res) { return res.json(); });
  if (mySeq !== seq) return;           // 已有更新的请求,丢弃本次结果
  render(data);
}

// 并行时给每个 Promise 挂兜底,避免 unhandled rejection
function safe(p) {
  return p.catch(function (err) { return { error: err }; });
}
const [a, b, c] = await Promise.all([safe(p1), safe(p2), safe(p3)]);

// 竞速后清理输家:race 不会取消其余任务
const controller = new AbortController();
const fastest = await Promise.race([
  fetch('/cdn-a/data.json', { signal: controller.signal }),
  fetch('/cdn-b/data.json', { signal: controller.signal })
]);
controller.abort();                    // 手动取消剩下的那个

// 组件卸载时统一清理,避免回调继续执行
function mount() {
  const id = setInterval(refresh, 5000);
  const onResize = function () { relayout(); };
  window.addEventListener('resize', onResize);
  return function dispose() {
    clearInterval(id);
    window.removeEventListener('resize', onResize);
  };
}

排查异步问题的顺序建议:先看 Network 面板确认请求是否真的发出、顺序是否正确;再看 Performance 面板找长任务;最后才怀疑代码逻辑。多数“异步 bug”其实是请求时序问题。