promise语法
promise 是某个函数返回的对象,代表异步操作完成或失败的对象。之前常用的是由其他函数创建并返回的 promise。
旧式函数:
function successCallback(result) {
console.log("It succeeded with " + result);
}
function failureCallback(error) {
console.log("It failed with " + error);
}
doSomething(successCallback, failureCallback);
新式函数:
let promise = doSomething();
promise.then(successCallback, failureCallback);
简化版:
doSomething().then(successCallback, failureCallback);
这种新写法被称为异步函数调用
保证:
- 在JavaScript事件队列的当前运行完成之前,回调函数永远不会被调用。
- 通过
.then
形式添加的回调函数,甚至都在异步操作完成之后才被添加的函数,都会被调用,如上所示。- 通过多次调用
.then
,可以添加多个回调函数,它们会按照插入顺序并且独立运行。
链式调用
当需要连续执行多个异步操作,下一个操作需要带着上一步的结果执行时,可以用 promise 的链式调用
== then 会返回一个新的 promise ==
const promise = doSomething();
const promise2 = promise.then(successCallback, failureCallback);
或
let promise2 = doSomething().then(successCallback, failureCallback);
promise
不仅代表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 chain:
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)
的缩略形式。如下所示,也可以用箭头函数来表示:
doSomething()
.then(result => doSomethingElse(result))
.then(newResult => doThirdThing(newResult))
.then(finalResult => {
console.log(`Got the final result: ${finalResult}`);
})
.catch(failureCallback);
注意: 一定要返回promise
,不然的话回调不会形成链式,错误也获取不到(当省略{}
时,箭头函数将隐式返回)。
catch之后的链式操作
链式中的一个动作失败之后如何继续使用promise
链式操作?
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();
}
timing
为了避免意外,传递给then
的函数永远不要再同步调用,即使它是一个已经变成resolve
状态的promise
:
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