别再让异步代码悄悄翻车:Promise 与 async/await 实战指南
Promise 不是魔法,它就是一套“结果回来之后怎么办”的写法。本文按 MDN 的《使用 Promise》指南与 Promise 参考页讲清楚:三种状态、then 的 return 铁律、扁平链、async/await、四个并发工具、微任务时序,附五类翻车现场。

先把这篇的边界说清楚。站里已经有《异步协作工作流》,讲的是让 AI 助手跑长任务时怎么拆步骤、怎么交接——那篇讲的是人和助手怎么协作,这篇讲的是代码:JavaScript 里等一个结果回来,到底有几种写法,每种写法会在哪里翻车。还有一篇《URL 查询参数实战》讲地址怎么拆,这篇不讲地址,只讲时间:先干什么、后干什么、几件事能不能一起干。下面用到的“雾岛小店”是一个虚构的练手项目:一个帮街边小店接单的网页小工具,用户点菜下单,程序先查库存、再算价格、最后提交订单。本文所有以它为例的操作、代码和数字,都是为了讲清楚做法编出来的,不是真实记录。所有关于 Promise 的语法、方法和行为,都来自 MDN 的《使用 Promise》指南与 Promise 参考页,来源见每篇的 meta 信息与 evidence 记录。MDN 文档里的例子,比如 doSomething 的链式调用、配料清单的例子,都是文档自带的示例,不是真实用户数据。
第一步:回调金字塔为什么让人难受
做网页的时候,很多事不是立刻有结果的:向服务器要一份菜单要等网络回来,读本地文件要等磁盘,定时器要等时间到。最早的写法是回调:把“做完之后干什么”写成一个函数,当作参数传进去。只做一件事的时候,这样写没什么问题。可一旦事情变成“先查库存,库存够了再算价格,价格算好了再提交订单”,回调就得一层套一层。MDN 文档里给了一个很直观的例子:doSomething 套着 doSomethingElse,再套着 doThirdThing,每一层都要重复写一遍失败回调 failureCallback。代码向右越缩越窄,读起来像一座金字塔,改起来更难:中间某一步想加一个判断,或者想把失败处理统一收口,你得在三层嵌套里同时动手,漏掉一层,错误就悄悄溜走了。
第二步:Promise 只有三种状态,认准了就不会晕
一个 Promise 从生下来起,只有三种状态。第一种是待定,英文叫 pending:事情还没完,成功还是失败都还不知道。第二种是已兑现,英文叫 fulfilled:事情办成了,带着一个成功的值。第三种是已拒绝,英文叫 rejected:事情办砸了,带着一个失败的原因。MDN 的 Promise 参考页把这一点写得很死:一个待定的 Promise,最终只能走向兑现或者拒绝,二选一;一旦落定,状态就再也不会变了。已经兑现的 Promise 不会再变成拒绝,已经拒绝的也不会再变成兑现。这个“落定就不再变”的保证,是后面所有写法的前提。
状态怎么变?只有两条路。创建 Promise 的时候,你要传一个执行器函数,英文叫 executor,它会立刻同步执行,并且拿到两个函数当参数:resolve 和 reject。你在执行器里调 resolve(值),Promise 就兑现,带着这个值;调 reject(原因),Promise 就拒绝,带着这个原因。执行器本身是同步跑的,这一点后面讲微任务时序还会回来验证。很多新手以为 new Promise 里面的代码是异步的,其实不是:new Promise 的那一刻,执行器已经跑完了,异步的只是 then 回调被调用的时机。
第三步:then 会返回一个新的 Promise,漏了 return 就断链
Promise 最核心的一句话,MDN 在指南开头就写出来了:then 方法会返回一个新的 Promise,和原来的那个不一样。这个新 Promise 代表的不只是原来那件事做完了,还包括你传进去的成功回调或者失败回调做完了。如果回调里又返回了一个 Promise,新的 Promise 会先等它落定,再把它的兑现值传给下一个回调。正因为这样,链才能一节一节往下接:doSomething().then(查库存).then(算价格).then(提交订单).catch(统一处理失败)。每一节的输入,都是上一节的输出,顺序写在纸面上就是执行的顺序,这正是回调金字塔做不到的事。
这条规则带来一个铁律:then 的回调里凡是遇到 Promise,一定要把它 return 出去。MDN 用一个配料清单的例子把后果讲得很具体:doSomething 先返回一个地址,回调里调 fetch 去拿数据,却忘了写 return,下一节的 then 拿到的就是 undefined,更糟的是,下一节会在 fetch 还没跑完的时候就执行,配料清单打印出来永远是空数组。漏了 return,Promise 就成了“漂浮的 Promise”,英文叫 floating promise:它还在后台跑,但链已经不管它了,它成功还是失败,链都收不到。更危险的是竞态:如果后面的步骤读了前面的结果,而前面的请求还没回来,读到的就是没写完的数据,时好时坏,测的时候还不一定复现。
修法只有一句话:凡是遇到 Promise 就 return,交给下一节 then 去处理。MDN 还给了一个更彻底的建议:把嵌套的链拍平。配料的例子本来是外层 then 里面再套一层 fetch().then().then(),拍平之后变成一节接一节的单链:先拿地址,再 fetch,再解析 JSON,再放进清单,每一步都是一节,错误处理也只需要一个 catch。拍平不是为了好看,是为了让错误的出口只有一个地方,调试的时候顺着链往下走,每一步的输入输出都看得见。
第四步:错误处理只有一个出口,但嵌套会开小门
Promise 链最让人安心的一点,是错误会顺着链往下找 catch。MDN 拿同步代码做了一个对照:同步写法里,try 包住三步,任何一步抛错都会掉进同一个 catch;Promise 链也一样,链上任何一节抛错或者返回一个拒绝的 Promise,错误都会一路向下,直到被 catch 接住。所以正常情况下,你不需要在每一节都写失败处理,只需要在链尾挂一个 catch,整条链的错误就都有了着落。MDN 的原话是:你几乎不需要在不用 async/await 的情况下写 try/catch,链尾的 catch 就是你的 try/catch。
但这个“只有一个出口”有个例外:嵌套。MDN 专门讲了嵌套是用来限制 catch 作用范围的控制结构:内层的 catch 只管内层那几步的失败,管不到外层。文档里的例子是 doSomethingCritical 后面嵌套了 doSomethingOptional 和 doSomethingExtraNice,内层 catch 把可选步骤的失败悄悄吞掉,然后继续走更关键的 moreCriticalStuff;如果一开始的 doSomethingCritical 就失败了,内层 catch 是不会接的,只有链尾的外层 catch 会接。这套写法本身没错,它让“可选步骤失败了也能继续”成为可能,但代价是链上出现了两个出口。MDN 的建议很直白:如果你没有这么精细的错误处理需求,就不要嵌套 then,用扁平的链,把错误处理逻辑放在链尾。嵌套不是不能用,是每嵌套一次,就要多想一次“这个 catch 到底管哪几步”。
第五步:async/await 是同一套东西的另一种写法
async/await 不是 Promise 的替代品,它就是 Promise 的另一种写法。MDN 的原话是:async/await 建立在 Promise 之上。配料清单的例子用 async/await 重写之后,代码看起来和同步代码一模一样,只是多了几个 await:先 await doSomething 拿地址,再 await fetch 拿响应,再 await res.json 拿数据,最后放进清单。读起来是自上而下的顺序,改起来也是:想在中间加一步判断,直接在两行之间插一行,不用重新排括号。
但“看起来像同步”不等于“就是同步”。MDN 提醒了两点。第一,await 只会停住它所在的那个 async 函数里依赖这个值的部分,整个程序不会停下,其他异步任务照样跑。await 在一个函数里等,不代表别的函数也在等。第二,async 函数永远返回一个 Promise:你在里面 return 一个普通值,外面拿到的是一个兑现为这个值的 Promise;你在里面抛错,外面拿到的是一个拒绝的 Promise。所以 async 函数之间照样可以链式调用,await 一个 async 函数,和 then 一个 Promise,是一回事。
错误处理在 async/await 里回到同步的老样子:try/catch。MDN 把链式写法的例子逐句翻译成 async/await:try 里面依次 await 三步,catch 里面接失败回调。关键步骤失败时想让可选步骤失败也不停,就在里面再套一层 try/catch,只包住可选的那两步,外层 catch 只管关键步骤。这个结构和上一节嵌套 then 的例子是一一对应的,区别只是写法:内层 try/catch 比内层 then/catch 好读得多,因为代码没有向右缩进去。选哪种写法,看团队习惯;但要记住,async/await 的 try/catch 只接得住 await 过的 Promise 的拒绝,没 await 的 Promise 拒绝了,它是接不住的,错误会变成未处理的拒绝,悄悄溜到全局去。
第六步:漏写 await,是最安静的翻车
Promise 链漏写 return 会断链,async/await 漏写 await 会拿到一个 Promise 当值用。MDN 在讲 async/await 的时候只用一句话带过这个坑:很容易忘记写 await,唯一的补救是类型不匹配的时候能发现——比如你想对一个 Promise 调字符串方法,立刻就报错。但更多时候,类型是对得上的,或者错得不够明显:你把一个 Promise 存进变量,后面当成普通对象去读它的属性,读到的全是 undefined,程序不报错,只是结果全错。这种错最难查,因为报错的地方离漏写 await 的地方隔了十万八千里。
第七步:四个并发工具,先分清“等谁”再选
一件事做完再做下一件,叫串行;几件事同时开始、一起等结果,叫并发。MDN 列了四个并发工具,全部是 Promise 的静态方法,全部接受一个可迭代对象、返回一个新的 Promise。它们的区别只有一个:等的条件不一样。Promise.all 是“全都要”:全部兑现才兑现,任何一个拒绝就立刻拒绝。Promise.allSettled 是“全都要有结果”:不管兑现还是拒绝,等全部落定才兑现,返回的结果里每一项都写明了状态和值或者原因。Promise.any 是“任何一个就行”:任何一个兑现就兑现,全部拒绝才拒绝,拒绝时带着一个 AggregateError,里面装着所有拒绝的原因。Promise.race 是“谁先落定听谁的”:第一个落定的 Promise 是兑现就是兑现,是拒绝就是拒绝。
选错工具的代价各不相同。MDN 特别提醒了 Promise.all 的一个行为:它拒绝的时候,其他几件事并不会停下,它们还在后台继续跑,只是它们的结果再也拿不到了。这可能造成意料之外的状态:比如三件事里第一件失败了,all 立刻拒绝,可第二件随后成功,还往数据库里写了一条记录,你的程序却以为整批都没做。遇到“部分失败也要知道每一项结果”的场景,就该用 allSettled;遇到“三个镜像源随便哪个先回来就用哪个”的场景,any 比 race 更合适,因为 race 会把第一个拒绝也当作结果,而 any 会等到有一个成功为止;只有明确想要“第一个结果,不管成败,还要拿它当超时信号”的时候,race 才是对的。选工具之前,先把问题写成一句话:“我要等到什么条件才算完?”答案直接对应四个工具里的一个。
第八步:串行还是并发,先问“后一步要不要前一步的结果”
MDN 在讲完并发工具之后,补了一句很容易被忽略的建议:在把 Promise 串起来之前,先想一想是不是真的有必要串行——能并发跑的,就不要让它们互相等,除非后一个的执行依赖前一个的结果。判断标准只有一条:后一步要不要前一步的结果。查库存的结果决定要不要算价格,这是依赖,必须串行;查菜单和查用户信息互不相干,就可以并发,用 Promise.all 一起等。把不相干的事写成串行,页面会白白多等几轮网络;把有依赖的事写成并发,后一步读到的就是没算完的数据。
第九步:只有包装旧接口的时候,才需要手写 new Promise
MDN 的原话是:从头创建 Promise 应该只在包装旧接口的时候才需要。理想情况下,所有异步函数本来就该返回 Promise;现实是,有些老接口还在用回调,比如 setTimeout。包装的方法是写一个最薄的壳:const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),然后永远只调 wait,再也不直接调 setTimeout。壳要包在尽可能低的一层,包一次,到处用。执行器里如果不需要失败分支,reject 可以不写,像 wait 这样;如果老接口可能失败,执行器里要在失败回调中调 reject,把失败传进 Promise 的世界,否则错误永远进不了 catch。
第十步:微任务时序,先记住 1、2、3、4 这组数字
Promise 回调什么时候执行?MDN 给了三条硬保证。第一,then 注册的回调,永远不会在当前这一轮事件循环跑完之前执行。第二,哪怕 Promise 早就落定了,之后才注册的回调也照样会执行,不会因为“来晚了”就错过。第三,同一个 Promise 上注册多个 then 回调,会按注册顺序一个接一个执行。把这三条合起来看,意思就是:Promise 回调永远是异步的,永远按顺序来,永远不会丢。
文档里有一组数字很适合背下来:Promise.resolve().then(() => console.log(2)),然后 console.log(1),输出永远是 1、2。因为 then 的回调被放进了微任务队列,要等当前同步代码跑完、执行栈空了才跑。另一组更完整的例子是:wait(0).then(() => console.log(4)),接着两个 then 分别打印 2 和 3,最后 console.log(1),输出是 1、2、3、4。微任务先于定时器任务执行,所以同样是等 0 毫秒,Promise 的回调比 setTimeout 的回调先跑。还有一个执行器同步执行的例子:new Promise 里面先打印“Promise callback”,再打印“Promise (pending)”,然后才打印“Promise callback (.then)”,最后 setTimeout 里打印“Promise (fulfilled)”。这组输出把“执行器同步跑、then 回调微任务跑、定时器最后跑”三件事一次讲清了,值得在控制台亲手跑一遍。
第十一步:没人接的拒绝,会冒泡到全局
如果一个 Promise 拒绝了,却没有任何处理器接它,错误不会消失,它会冒泡到调用栈顶,由宿主环境来处理。在浏览器里,这时会触发两个全局事件:unhandledrejection,在一个 Promise 被拒绝、又没有任何拒绝处理器的时候发送;rejectionhandled,在一个已经触发过 unhandledrejection 的 Promise 后来又被接住的时候发送。两个事件都带有一个 promise 属性,指明是哪个 Promise,还有一个 reason 属性,说明拒绝的原因。Node.js 里的做法略有不同,监听的是 process 的 unhandledRejection 事件,注意大小写和浏览器里的事件名不一样。MDN 还提醒了一句:如果在 Node.js 里只加了监听却不处理,拒绝会被悄悄丢掉,所以监听函数里一定要检查每一个拒绝是不是真正的代码缺陷。
第十二步:五类翻车现场,先对着图自查

上图是虚构的雾岛小店项目一个季度的统计:异步相关的事故一共 96 次。漏写 return 断链 28 次,占 29.2%,是最多的;漏写 await 拿到 Promise 当值用 24 次,占 25.0%;串行与并发选错 16 次,占 16.7%;catch 位置放错、该接的没接住 15 次,占 15.6%;未处理的拒绝冒泡到全局 13 次,占 13.5%。28 加 24 加 16 加 15 加 13 等于 96,账是平的。这些数字是编出来的例子,目的是让你一眼看到:前两类加起来超过一半,而它们都是同一类错误的不同写法——链上少了一个 return,或者 await 前面少了一个 await。
自查清单:写完异步代码,逐条打勾
第一,链是扁平的,没有无缘无故的嵌套。第二,每个 then 回调里返回 Promise 的地方都写了 return,没有漂浮的 Promise。第三,async 函数里调用异步函数的地方,要么写了 await,要么写了注释说明为什么不等。第四,并发工具选对了:全都要用 all,全都要有结果用 allSettled,任何一个成功就行用 any,第一个落定就听谁的用 race。第五,串行与并发分得清:后一步不要前一步的结果就并发,要就串行。第六,每一处失败都有出口:链尾有 catch,async 函数里有 try/catch。第七,只有包装 setTimeout 这类老回调接口的时候才手写 new Promise。第八,then 回调在同步代码之后、定时器之前执行。第九,取消操作找的是 AbortController 这类底层机制。十条里任何一条答不上来,回到对应的章节再读一遍,比多背十个 API 都有用。
评论 (0)
原始来源
相关文章
Flexbox 一次只排一个方向,排对了,导航栏、卡片墙、购物车行都听话。本文按 MDN 的《Basic concepts of flexbox》《Aligning items in a flex container》《Controlling ratios of flex items along the main axis》三篇官方文档讲清楚:两根轴、容器与项目、方向与换行、剩余空间、flex 三件套、两根轴上的对齐、间距与自动边距。
一张点单就是一个对象:桌号、菜品、总价、付没付钱,全按标签收在一起。本文按 MDN 的《Working with objects》《JSON》《Object》三篇官方文档讲清楚:对象字面量、点号与方括号、增删改查、for...in 配 hasOwn、方法与 this、getter 与 setter、引用与复制、Object.assign 等工具箱、空白原型对象、JSON 的严规矩,以及 stringify 与 parse 和数字精度的坑。
函数你每天都在调,这篇把你一直在做的事讲清楚。本文按 MDN 的《Functions》《Arrow function expressions》《Rest parameters》三篇官方文档讲清楚:声明与表达式、参数与实参、默认值、剩余参数、展开语法、返回值、箭头函数省写规则、this 的坑、回调与高阶函数、作用域。