async/await 让异步代码看起来像同步代码,这是它的价值,也是它最大的陷阱——看起来像同步,就容易被当成同步来写。

这篇记录三种我见过最多、也最容易在 code review 里漏掉的误用。

误用一:在循环里 await,把并行写成串行

// 慢:一个接一个,总耗时 = 各请求之和
async function loadAll(ids) {
  const results = [];
  for (const id of ids) {
    results.push(await fetchItem(id));
  }
  return results;
}

十个请求,每个 200ms,总耗时两秒。但它们之间根本没有依赖关系。

改法:

// 快:并发发起,总耗时 ≈ 最慢的那一个
async function loadAll(ids) {
  return Promise.all(ids.map((id) => fetchItem(id)));
}

如果请求量很大(几百上千),别直接 Promise.all 打出去,会打爆连接数。加个并发上限:

async function pool(items, limit, worker) {
  const queue = [...items];
  const runners = Array.from({ length: limit }, async () => {
    while (queue.length) {
      await worker(queue.shift());
    }
  });
  await Promise.all(runners);
}

误用二:忘了 await,错误变成 unhandled rejection

async function save(data) {
  db.write(data); // 忘了 await
  return { ok: true };
}

调用方拿到 { ok: true } 的时候,写入可能还没开始,也可能已经失败了。而这个失败不会抛到 try/catch 里,它会变成一个 unhandled rejection,安静地躺在控制台角落。

没有 await 的异步调用,等于把错误扔进了黑洞。

ESLint 有一条规则可以救命:

{
  "rules": {
    "no-floating-promises": "error"
  }
}

误用三:串行依赖被误判成并行

反过来也有。有人为了"性能",把本来有依赖的调用改成并行:

// 错:token 还没拿到就用
const [user, token] = await Promise.all([fetchUser(), getToken()]);
const profile = await fetchProfile(user.id, token);

这里 fetchProfile 依赖前两个的结果,本身没问题。但如果 fetchUser 内部也需要 token,那这段就是错的,而且错得很隐蔽——有时候能跑通,因为 token 有缓存。

一条实用原则

判断该不该 await,只问一个问题:

后面的代码,需要这个结果吗?

  • 需要 → await
  • 不需要,但要等它完成 → 收集起来,最后 Promise.all
  • 完全不需要等(日志上报之类)→ 显式地不 await,并加注释说明

最后这条很重要。写清楚"我知道这里没 await,这是故意的",比让下一个人猜要好得多。

收尾

异步代码的可读性,不在于用了多少 async,而在于依赖关系有没有被显式地画出来。

Promise.all 是一句宣言:这些事互不相干。await 是一句宣言:我在等这个。把这两句话用对,异步就直白了。