翻译正在进行中。

一个 Promise 就是一个代表了异步操作最终完成或者失败的对象。大多数人都在使用由其他函数创建并返回的promise,因此,本教程将首先探讨返回promise的使用情况。

promise本质上是一个绑定了回调的对象,而不是将回调传进函数内部。

假设存在一个名为createAudioFileAsync()的方法,这个方法通过一个参数以及两个回调函数创建一个声音文件,在声音文件成功创建或者创建失败后执行回调函数。

以下为createAudioFileAsync()的示例:

function successCallback(result) {
  console.log("Audio file ready at URL: " + result);
}

function failureCallback(error) {
  console.log("Error generating audio file: " + error);
}

createAudioFileAsync(audioSettings, successCallback, failureCallback)

...新式函数返回一个你可以直接绑定回调函数的promise对象,来代替旧式的函数形式:

const promise = createAudioFileAsync(audioSettings); 
promise.then(successCallback, failureCallback);

…或者更简单的形式:

createAudioFileAsync(audioSettings).then(successCallback, failureCallback);

我们把这个称为异步函数调用,这种形式有若干优点。我们将会逐一讨论。

约定

不同于老式的传入回调,在应用promise时,我们将会有以下约定:

  • 在JavaScript事件队列的当前运行完成之前,回调函数永远不会被调用。
  • 通过 .then 形式添加的回调函数,甚至都在异步操作完成之后才被添加的函数,都会被调用,如上所示。
  • 通过多次调用 .then,可以添加多个回调函数,它们会按照插入顺序并且独立运行。

因此,promise最直接的好处就是链式调用。

链式调用

一个常见的需求就是连续执行两个或者多个异步操作,这种情况下,每一个后来的操作都在前面的操作执行成功之后,带着上一步操作所返回的结果开始执行。我们可以通过创造一个promise chain来完成这种需求。

见证奇迹的时刻:then函数会返回一个新的promise,跟原来的不同:

const promise = doSomething();
const promise2 = promise.then(successCallback, failureCallback);

或者

const promise2 = doSomething().then(successCallback, failureCallback);

第二个对象(promise2)不仅代表doSomething()函数的完成,也代表了你传入的 successCallback 或者failureCallback 的完成,这也可能是其他异步函数返回的promise。这样的话,任何被添加给 promise2 的回调函数都会被排在 successCallback 或 failureCallback 返回的promise后面。

基本上,每一个promise代表了链式中另一个异步过程的完成。

在过去,做多重的异步操作,会导致经典的回调地狱:

doSomething(function(result) {
  doSomethingElse(result, function(newResult) {
    doThirdThing(newResult, function(finalResult) {
      console.log('Got the final result: ' + finalResult);
    }, failureCallback);
  }, failureCallback);
}, failureCallback);

通过新式函数,我们把回调绑定到被返回的promise上代替以往的做法,形成一个promise 链:

doSomething().then(function(result) {
  return doSomethingElse(result);
})
.then(function(newResult) {
  return doThirdThing(newResult);
})
.then(function(finalResult) {
  console.log('Got the final result: ' + finalResult);
})
.catch(failureCallback);

then里的参数是可选的,catch(failureCallback) 是 then(null, failureCallback) 的缩略形式。如下所示,也可以用 arrow functions(箭头函数)来表示:

doSomething()
.then(result => doSomethingElse(result))
.then(newResult => doThirdThing(newResult))
.then(finalResult => {
  console.log(`Got the final result: ${finalResult}`);
})
.catch(failureCallback);

注意:如果想要在回调中获取上个promise中的结果,上个promise中必须要返回结果。

Catch 的后续链式操作

在一个失败操作(即一个 catch)之后可以继续使用链式操作,即使链式中的一个动作失败之后还能有助于新的动作继续完成。请阅读下面的例子:

new Promise((resolve, reject) => {
    console.log('Initial');

    resolve();
})
.then(() => {
    throw new Error('Something failed');
        
    console.log('Do this');
})
.catch(() => {
    console.log('Do that');
})
.then(() => {
    console.log('Do this whatever happened before');
});

输出结果如下:

Initial
Do that
Do this whatever happened before

注意,由于“Something failed”错误导致了拒绝操作,所以“Do this”文本没有被输出。

错误传播

在之前的回调地狱示例中,你可能记得有3次failureCallback的调用,而在promise链中只有底部的一次调用。

doSomething()
.then(result => doSomethingElse(value))
.then(newResult => doThirdThing(newResult))
.then(finalResult => console.log(`Got the final result: ${finalResult}`))
.catch(failureCallback);

基本上,一个promise链式遇到异常就会停止,查看链式的底端,寻找catch处理程序来代替当前执行。在同步的代码执行之后,这是非常模型化的。

try {
  let result = syncDoSomething();
  let newResult = syncDoSomethingElse(result);
  let finalResult = syncDoThirdThing(newResult);
  console.log(`Got the final result: ${finalResult}`);
} catch(error) {
  failureCallback(error);
}

在ECMAScript 2017标准的async/await语法糖中,这种同步形式代码的整齐性得到了极致的体现:

async function foo() {
  try {
    let result = await doSomething();
    let newResult = await doSomethingElse(result);
    let finalResult = await doThirdThing(newResult);
    console.log(`Got the final result: ${finalResult}`);
  } catch(error) {
    failureCallback(error);
  }
}

这个例子是在promise的基础上构建的,例如,doSomething()与之前的函数是相同的。你可以在这里阅读更多的与这个语法相关的文章。

通过捕获所有的错误,甚至抛出异常和程序错误,promise解决了回调地狱的基本缺陷。这是异步操作的基本功能。

在旧式回调API中创建Promise

 Promise通过它的构造器从头开始创建。 只应用在包裹旧的API。

理想状态下,所有的异步函数都已经返回promise了。但有一些API仍然使用旧式的被传入的成功或者失败的回调。典型的例子就是setTimeout()函数:

setTimeout(() => saySomething("10 seconds passed"), 10000);

混用旧式回调和promise是会有问题的。如果 saySomething  函数失败了或者包含了编程错误,那就没有办法捕获它了。

幸运的是我们可以用promise来包裹它。最好的做法是将有问题的函数包装在最低级别,并且永远不要再直接调用它们:

const wait = ms => new Promise(resolve => setTimeout(resolve, ms));

wait(10000).then(() => saySomething("10 seconds")).catch(failureCallback);

通常,promise的构造器会有一个可以让我们手动操作resolve和reject的执行函数。既然 setTimeout 没有真的执行失败,那么我们可以在这种情况下忽略reject。

组合

Promise.resolve()Promise.reject() 是手动创建一个已经resolve或者reject的promise快捷方法。它们有时很有用。

Promise.all()Promise.race()是并行运行异步操作的两个组合式工具。

时序组合可以使用一些优雅的javascript形式:

[func1, func2].reduce((p, f) => p.then(f), Promise.resolve());

通常,我们递归调用一个由异步函数组成的数组时相当于一个promise链式:Promise.resolve().then(func1).then(func2);

我们也可以写成可复用的函数形式,这在函数式 编程中极为普遍:

let applyAsync = (acc,val) => acc.then(val);
let composeAsync = (...funcs) => x => funcs.reduce(applyAsync, Promise.resolve(x));

composeAsync函数将会接受任意数量的函数作为其参数,并返回一个新的函数,该函数接受一个通过composition pipeline传入的初始值。这对我们来说非常有益,因为任一函数可以是异步 或同步的,它们能被保证按顺序执行:

let transformData = composeAsync(func1, asyncFunc1, asyncFunc2, func2);
transformData(data);

在 ECMAScript 2017标准中, 时序组合可以通过使用async/await而变得更简单:

for (let f of [func1, func2]) {
  await f();
}

时序

为了避免意外,即使是一个已经变成 resolve 状态的 promise,传递给 then 的函数也总是会被异步调用:

Promise.resolve().then(() => console.log(2));
console.log(1); // 1, 2

传递到then中的函数被置入了一个微任务队列,而不是立即执行,这意味着它是在JavaScript事件队列的所有运行时结束了,事件队列被清空之后才开始执行:

const wait = ms => new Promise(resolve => setTimeout(resolve, ms));

wait().then(() => console.log(4));
Promise.resolve().then(() => console.log(2)).then(() => console.log(3));
console.log(1); // 1, 2, 3, 4

嵌套

简便的Promise链式编程最好保持扁平化,不要嵌套Promise,嵌套经常会是粗心导致的。可查阅下一节的常见错误中的例子。

嵌套Promise是一种可以限制catch语句的作用域的控制结构写法。明确来说,嵌套的catch仅捕捉在其之前同时还必须是其作用域的failureres,而捕捉不到在其链式以外或者其嵌套域以外的error。如果使用正确,那么可以实现高精度的错误修复。

doSomethingCritical()
.then(result => doSomethingOptional()
  .then(optionalResult => doSomethingExtraNice(optionalResult))
  .catch(e => {console.log(e.message)})) // 即使有异常也会忽略,继续运行;(最后会输出)
.then(() => moreCriticalStuff())
.catch(e => console.log("Critical failure: " + e.message));//没有输出

注意,有些代码步骤是嵌套的,而不是一个简单的纯链式,这些语句前与后都被()包裹着。

这个内部的catch语句仅能捕获到doSomethingOptional()doSomethingExtraNice()的失败,而且还是在moreCriticalStuff()并发运行以后。重要提醒,如果doSomethingCritical()失败,这个错误才仅会被最后的(外部)catch语句捕获到。

常见错误

在编写 promise chain 时,需要注意以下示例中显示了以下几个错误:

// Bad example! Spot 3 mistakes!

doSomething().then(function(result) {
  doSomethingElse(result) // Forgot to return promise from inner chain + unnecessary nesting
  .then(newResult => doThirdThing(newResult));
}).then(() => doFourthThing());
// Forgot to terminate chain with a catch!
​​​​​​

第一个错误是没有正确地将事物相连接。当我们创建新 promise 但忘记返回它时,会发生这种情况。因此,链条被打破,或者更确切地说,我们有两个独立的链条竞争。这意味着 doFourthThing() 不会等待 doSomethingElse()doThirdThing() 完成,并且将与它们并行运行,可能是无意的。单独的链也有单独的错误处理,导致未捕获的错误。

第二个错误是不必要地嵌套,实现第一个错误。嵌套还限制了内部错误处理程序的范围,如果是非预期的,可能会导致未捕获的错误。其中一个变体是 promise 构造函数反模式,它结合了promise构造函数的多余使用和嵌套。

第三个错误是忘记用 catch 终止链。这导致在大多数浏览器中不能终止的 promise 链里的 rejection。

一个好的经验法则是总是返回或终止承诺链,并且一旦你得到一个新的承诺,返回它,来平面化代码:

 

doSomething()
.then(function(result) {
  return doSomethingElse(result);
})
.then(newResult => doThirdThing(newResult))
.then(() => doFourthThing());
.catch(error => console.log(error));

现在我们有一个具有适当错误处理的确定性链。

使用 async/await 解决了大多数,如果不是所有这些问题的话 - 最常见的错误就是忘记了await 关键字。

参见:

文档标签和贡献者

标签: 
最后编辑者: yonoel,