使用Promise
Promise 是一个对象,它代表了一个异步操作的最终完成或者失败。因为大多数人不仅仅是使用创建的Promise实例对象,所以本教程将首先说明怎样使用Promise,再说明如何创建Promise。
本质上Promise是一个函数返回的对象,我们可以在它上面绑定回调函数,这样我们就不需要在一开始把回调函数作为参数传入这个函数了。
假设现在有一个名为createAudioFileAsync()的函数,它接收一些配置和两个回调函数,然后异步地生成音频文件。一个回调函数在文件成功创建时被调用,另一个则在出现异常是被调用。
以下为使用 createAudioFileAsync()的示例:
// 成功的回调函数
function successCallback(result){
console.log("音频文件创建成功:" + result);
}
// 失败的回调函数
function failureCallback(error){
console.log("音频文件创建失败:" + error);
}
createAudioFileAsync(audioSettings, successCallback, failureCallback)
更现代的函数会返回一个Promise对象,使得你可以将你的回调函数绑定在该Promise上。
如果函数createAudioFileAsync()被重写为返回 Promise的形式,那么我们可以像下面这样简单的调用它:
const promise = createAudioFileAsync(audioSettings);
promise.then(successCallback, failureCallback);
或者简写为:
createAudioFileAsync(audioSettings).then(successCallback, failureCallback);
我们把这个称为 异步函数调用,这种形式有若干优点,下面我们将会逐一讨论。
约定
不同于“老式”的传入回调,在使用Promise时,会有以下约定:
在本轮事件循环运行完成之前,回调函数是不会被调用的。
即使异步操作已经完成(成功或失败),在这之后通过then()添加的回调函数也会被调用。
通过多次调用then() 可以添加多个回调函数,它们会按照插入顺序进行执行。
Promise很棒的一点就是链式调用。
链式调用
连续执行两个或者多个异步操作是一个常见的需求,在上一个操作执行成功之后,开始下一个的操作,并带着上一步作所返回的结果。我们可以通过创造一个Promise链来实现这种需求。
见证奇迹的时刻:then() 函数会返回一个和原来不同的新的Promise:
const promise = doSomething();
const promise2 = promise.then(successCallback, failureCallback)
或者
const promise2 = doSomething().then(successCallback, failureCallback)
promise2 不仅表示 doSomething() 函数的完成,也代表了你传入的successCallback或者failureCallback的完成,这两个喊也可以返回一个Promise对象,从而形成另一个异步操作,这样的话,在Promise2 上新增的回调函数会排在这个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(filnalResult){
console.log("Got the final result:" + filnalResult);
})
.catch(failureCallback);
then里的参数是可选的,catch(failureCallback) 是 then(null, failureCallback) 的缩略形式。
如下所示,我们也可以用箭头函数来表示:
doSomething()
.then(return => doSomethingElse(result);)
.then(return => doThirdThing(newResult);)
.then(filnalResult => {
console.log(`Got the final result:${filnalResult}`);
})
.catch(failureCallback);
注意:一定要有返回值,否则,callback将无法获取上一个Promise的结果。(如果使用箭头函数,() => x 比 () => { return x;} 更简洁一些,但后一种保留return的写法才支持使用多个语句。)
Catch 的后续链式操作
有可能会在一个回调失败之后继续使用链式操作,即,使用一个catch,这对于在链式操作中抛出一个失败之后,再次进行新的操作会很有用。请阅读下面的例子:
new Promise((resolve, reject) => {
console.log('初始化')
resolve();
})
.then(() => {
throw new Error('有哪里不对了');
console.log('执行[这个]');
})
.catch(() => {
console.log('执行[那个]');
})
.then(() => {
console.log('执行[这个],无论前面发生了什么');
})
输出结果如下:
初始化
执行「那个」
执行「这个」,无论前面发生了什么
注意:因为抛出了错误 ‘有哪里不对了’,所以前一个‘执行执行「这个」’没有被输出。
错误传递
在之前的回调地狱示例中,你可能记得有3次failureCallback的调用,而在Promise链中只有尾部的一次调用。
doSomething()
.then(result => doSomethingElse(result))
.then(newResult => doThirdThing(newResult))
.then(finalResult => console.log(`Got the final result: ${finalResult}`))
.catch(failureCallback);
通常,一遇到异常抛出,浏览器就会顺着Promise链寻找下一个onRejected失败回调函数或者由 .catch() 指定的回调函数。这和以下同步代码的工作原理(执行过程)非常相似。
try {
let result = syncDoSomething();
let newResult = syncDoSomethingElse(result);
let finalResult = syncDoThirdThing(newResult);
console.log(`Got the final result: ${finalResult}`);
} catch(error) {
failureCallback(error);
}
在ECMAScript2017 标准的async/await语法糖中,这种异步代码的对称性得到了极致的体现:
async function foo() {
try{
const result = await doSomething();
const newResult = await doSomethingElse(result);
const finalResult = await doThirdThing(newResult);
console.log(`Got the final result:${finalResult}`);
} catch(error) {
failureCallback(error)
}
}
这个例子是在Promise的基础上构建的,例如,doSomething()与之前的函数是相同的。
通过捕获所有的错误,甚至抛出异常和程序错误,Promise解决了回调地狱的基本缺陷。这对于构建异步操作的基础功能而言是很有必要的。
Promise拒绝事件
当Promise被拒绝时,会有下文所述的两个事件之一被派发到全局作用域(通常而言,就是window;如果是在web worker 中使用的话,就是Worker或者其他worker-based接口),这两个事件如下所示:
rejectionhandled
当Promise被拒绝、并且reject函数处理该rejection之后会派发此事件。
unhandledrejection
当Promise被拒绝,但没有提供rejec函数来处理rejection时,会派发此事件。
以上两种情况中,PromiseRejectionEvent事件都有两个属性,一个是Promise属性,该属性指向被驳回的Promise,另一个是reason(en-US)属性,该属性用来说明Promise被驳回的原因。
因此,我们可以通过以上事件为Promise失败时提供补偿处理,也有利于调试Promise相关的问题。在每一个上下文,该处理都是全局的,因此不管源码如何,所有的错误都会同一个处理函数中被捕捉并处理。
一个特别有用的例子:当你使用Node.js时,有些依赖模块可能会有未被处理的rejected promises,这些都会在运行时打印到控制台。你可以在自己代码中捕捉这些信息,然后添加与unhandledrejection 相应的处理函数来做分析和处理,或只是为了让你的输出更整洁。举例如下:
window.addEventListener("unhandledrejection", event => {
/*
你可以在这里添加一些代码,以便检查
event.promise 中的 promise 和
event.reason 中的 rejection 原因
*/
event.preventDefault();
},false);
调用event的 preventDefault() 方法是为了告诉JavaScript引擎当 Promise 被拒绝时不要执行默认操作,默认操作一会包含把错误打印到控制台,Node就是如此的。
理想情况下,在忽略这些事件之前,我们应该检查所有被拒绝的Promise,来确认这不是代码中的bug.
在旧式回调API中创建Promise
可以通过Promise的构造器从零开始创建Promise。这种方式(通过构造器的方式)应当只在封装旧API的时候用到。
理想状态下,所有的异步函数都已经返回Promise了。但有一些API仍然使用旧方式来传入的成功(或者失败)的回调。典型的例子就是setTimeout()(en-US)函数:
setTimeout( () => saySomething('10 seconds passed'), 1000);
混用旧式回调和Promise可能会造成运行时序问题。如果 saySomething 函数失败了,或者包含了编程错误,那就没有办法捕获它了。这得怪 setTimeout。
幸运地是,我们可以用Promise来封装它。最好的做法是,将这些有问题的函数封装起来,留在底层,并且永远不要再直接调用他们:
const wait = ms => new Promise( resolve => setTimeout(resolve, ms));
wait(1000).then(() => saySomething("10 seconds")).catch(failureCallback);
通常,Promise的构造器接收一个执行函数(executor),我们可以在这个执行函数里手动地 resolve 和 reject 一个Promise。既然setTimeout并不会真的执行失败,那么我们可以在这种情况下忽略 reject。
组合
Promise.resolve() 和 Promise.reject() 是手动创建一个已经resolve或者reject 的Promise快捷方法。它们有时很有用。
Promise.all() 和 Promise.race() 是并行运行异步操作的两个组合式工具。
我们可以发起并行操作,然后等多个操作全部结束后进行下一步操作,如下:
Promise.all([func1(), func2(), func3()])
.then(([ result1, result2, result3 ]) => { /* use result1, result2 and result3 */ });
可以使用一聪明得JavaScript写法实现时序组合:
[ func1, func2, func3 ].reduce((p, f) => p.then(f), Promise.resolve() )
.then( result3 => { /* use result3 */ });
通常,我们递归用一个有异步函数组成的数组时,相当于一个Promise链:
Promise.resolve().then(func1).then(func2).then(func3);
我们可以写成可复用的函数形式,这在函数式编程中极为普遍:
const applyAsync = (arr,val) => acc.then(val);
const composeAsync = (...funcs) => x => funcs.reduce(applyAsync, Promise.resolve(x));
composeAsync() 函数将会接受任意数量的函数作为其参数,并返回一个新的函数,该函数接受一个通过composition pipeline 传入的初始值。这对我们来说非常有益,任一函数可以是异步或同步的,它们能被保证按顺序执行:
const transformData = composeAsync( func1, func2, func3 );
const result3 = transformData(data);
在ECMAScript 2017标准中,时序组合可以通过使用async/await而变得更简单:
let result;
for( const f of [func1, func2, func3] ){
result = await f(result);
}
/* use last result (i.e.result3) */
时序
为了避免意外,即使是一个已经变成 resolve 状态的Promise,传递给then() 的函数也总是会被异步调用:
Promise.resolve().then( () => console.log(2));
console.log(1);
传递到then() 中的函数被置入到一个微任务队列中,而不是立即执行,这意味着它是在JavaScript事件队列的所有运行时结束了,且事件队列被清空之后,才开始执行:
const wait = ms => new Promise(resolve => setTimeout(reasolve, ms));
wait().then( () => console.log(4));
Promise.resolve().then(() => console.log(2)).then(() => console.log(3));
console.log(1);
嵌套
简便的Promise链式编程最好保持扁平化,不要嵌套Promise,因为嵌套经常会是粗心导致。可查阅下一节的常见错误中例子。
嵌套Promise是一种可以限制catch语句的作用域的控制结构写法。明确来说,嵌套的catch仅捕捉在其之前同时还必须是其作用域的failureres,而捕捉不到在其链式以外或者其嵌套以外的error。如果使用正确,那么可以实现高精度的错误修复。
doSomethingCritical()
.then( result => doSomethingCritical()
.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链时,需要注意以下示例中展示的几个错误:
// 错误示例,包含3个问题!
doSomething().then(function(result) {
doSomethingElse(result) // 没有返回 Promise 以及没有必要的嵌套 Promise
.then(newResult => doThirdThing(newResult));
}).then(() => doFourthThing());
// 最后,是没有使用catch终止Promise调用链,可能导致没有捕获的异常
第一个错误是没有正确地将事物相连接。当我们创建新Promise但忘记返回它时,会发生这种情况。因此,链条被打破,或者更确切地说,我们有两个独立的链条竞争(同时在执行两个异步而非一个一个的执行)。这意味着doFourthThing()不会等待doSomethingElse() 或者 doThirdThing() 完成,并且将与它们并行运行,可能是无意的,单独链也有单独的错误处理,导致未捕获的错误。
第二个错误时不必要地嵌套,实现第一个错误。嵌套还限制了内部错误处理程序的范围,如果是非预期的,可能会导致未捕获的错误。其中一个变体是Promise构造函数反模式,它结合了Promise构造函数的多余使用和嵌套。
第三个错误是忘记用catch终止链。这导致在大多数浏览器中不能终止的Promise链里的rejection。
一个好的经验法则是总是返回或终止Promise链,并且一旦你得到一个新的Promise,返回它。下面是修改后的平面化的代码:
doSomething()
.then(function(result) {
return doSomethingElse(result);
})
.then(newResult => doThirdThing(newResult))
.then(() => doThirdThing())
.catch(error => console.log(error));
注意:()=> x 是 ()=> { return x; }的简写。
上述代码的写法就是具有适当错误处理的简单明确的链式写法。
使用async/await可以解决以上大多数错误,使用async/await时,最常见的语法错误就是忘记await关键字