1.Promise含义
特点:
- 异步编程的一种解决方案(相较于回调函数和事件更合理,更强大)
- 一个保存着某个未来才会结束的事件(通常是一个异步操作)的结果的容器
- 对象的状态不受外界影响(pending进行中,fulfilled已成功,rejected已失败)
- 一旦状态改变,就不会再次变化,任何时候都可以得到这个结果(状态变化,只有两种可能:从pending转为fulfilled;从pending转为rejected)
- 将异步操作以同步操作的流程表达出来,避免层层嵌套的回调函数
缺点:
- 无法取消Promise,一旦新建会立即执行,无法中途取消
- 如果不设置回调函数,Promise内部抛出的错误不会反应到外部
- 当处于pending状态时,无法得知目前进行到那个阶段
2.基本用法
1 | const promise = new Promise(function(resolve,reject){ |
Promise构造函数接受一个函数作为参数,该参数的两个参数分别是resolve和reject。他们是两个函数,由JS引擎提供,不需要自己部署。
resolve函数的作用是将Promise对象的状态从未完成(pending)转换为已成功(resolved),在异步操作成功时调用,并将异步操作的结果作为参数传递过去。
reject函数的作用是将Promise对象的状态从未完成(pending)转换为已失败(rejected),在异步操作失败时调用,并将异步操作报出的错误作为参数传递出去。
Promise对象生成以后,可以使用then方法分别指定resolved状态和rejected状态的回调函数。
1 | promise.then(function(value){ |
then方法可以接受两个回调函数作为参数。第一个回调函数是Promise对象的状态变为resolved时调用,第二个回调函数时Promise对象的状态变为rejected时调用。其中,第二个函数是可选的,不一定要提供。这两个函数都接受Promise对象传出的值作为参数。
1 | function timeout(ms){ |
timeout方法返回一个Promise实例,表示一段时间以后才会发生的结果。过了指定的时间(ms参数)以后,Promise实例的状态变为resolved,就会触发then方法绑定的回调函数。
1 | let promise = new Promise(function(resolve,reject){ |
Promise新建后会立即执行,所以首先输出的是Promise。然后then方法指定的回调函数,将在当前脚本所有同步任务执行完才会执行,所以resolved最后输出。
1 | //异步加载图片示例 |
使用Promise包装了一个图片加载的异步操作,如果加载成功,就调用resolve方法,否则就调用reject方法。
1 | //Promise对象实现Ajax操作 |
getJSON是对XMLHttpRequest对象的封装,用于发出一个针对JSON数据的HTTP请求,并且返回一个Promise对象。
在getJSON内部,resolve函数和reject函数调用时,都带有参数。
如果调用resolve函数和reject函数时带有参数,那么他们的参数会被传递给回调函数。reject函数的参数通常是ERROR对象的实例,表示抛出的错误,resolve函数的参数除了正常的值以外,还可能是另一个Promise实例。
1 | //案例 |
p1和p2都是Promise的实例,但是p2的resolve方法将p1作为一个参数,即一个异步操作的结果是返回另一个异步操作。
需要注意的是:这时p1的状态就会传递给p2,也就是说p1的状态决定了p2的状态。如果p1的状态时pending,那么p2的回调函数就会等待p1的状态改变,如果p1的状态已经是resolved或者rejected,那么p2的回调函数将会立刻执行。
1 | const p1 = new Promise(function(resolve,reject){ |
p1是一个Promise,3秒之后变为rejected。p2的状态在1秒之后改变,resolve方法返回的是p1.由于p2返回的是另一个Prmise,导致p2自己的状态无效了,由p1的状态决定p2的状态。所以,后面的then语句都变成针对后者(p1).又过了2秒,p1变为rejected,导致触发catch方法指定的回到函数。
调用resolve或reject并不会终结Promise的参数函数的执行。
1 | new Promise((resolve,reject)=>{ |
调用resolve(1)后,后面的console.log(2)还是会执行,并且会首先打印出来。这是因为立即resolved的Promsie是在本轮事件循环的末尾执行,总是晚于本轮循环的同步任务。
一般来说,调用resolve或reject以后,Promise的使命就完成了,后续操作应该放到then方法里面,而不应该直接写在resolve或reject的后面。所以,最好在他们前面加上return语句,这样就不会有意外。
1 | new Promise((resolve,reject)=>{ |
3.Promise方法
Promise.prototype.then()
Promise实例具有then方法,也就是说,then方法是定义在原型对象Promise.prototype上的。它的作用是为Promise实例添加状态改变时的回调函数。前面说过,then方法的第一个参数是resolved状态的回调函数,第二个参数(可选)是rejected状态的回调函数。
then方法返回的是一个新的Promise实例(非原来的Promise实例)。因此可以采用链式写法:then方法后面再调用另一个then方法。
1 | getJSON("/posts.json").then(function(json){ |
使用then方法,依次指定了两个回调函数。第一个回调函数完成以后,会将返回结果作为参数,传入第二个回调函数。
采用链式的then方法,可以指定一组按照次序调用的回调函数。这时,前一个回调函数,有可能返回的还是一个Promise对象(即有异步操作),这时后一个回调函数,就会等待该Promise对象的状态发生变化,才会被调用。
1 | getJSON("/post/1.json").then(function(post){ |
第一个then方法指定的回调函数,返回的是另一个Promise对象。这是,第二个then方法指定的回调函数就会等待这个新的Promise对象状态发生变化。如果变为resolved,就调用第一个回调函数,如果状态变为rejected,就调用第二个回调函数。
采用箭头函数,可以使代码更简洁。
1 | getJSON("/post/1.json").then( |
Promise.prototype.catch()
Promise.prototype.catch方法是.then(null,rejection)或.then(undefined,rejected)的别名,用于指定发生错误时的回调函数。
1 | getJSON("/posts.json").then(function(posts){ |
getJSON方法返回一个Promise对象,如果该对象状态变为resolved,则会调用then方法指定的回调函数;如果异步操作抛出错误,状态就会变为rejected,就会调用catch方法指定的回调函数,处理这个错误。另外,then方法指定的回调函数,如果运行中抛出错误,也会被catch方法捕获。
1 | p.then((val) => console.log('fulfilled:', val)) |
1 | const promise = new Promise(function(resolve, reject) { |
promise抛出一个错误,就会被catch方法指定的回调函数捕获。
1 | // 写法一 |
reject方法的作用,等同于抛出错误。
如果Promise状态已经变成resolved,再抛出错误是无效的。
1 | const promise = new Promise(function(resolve,reject){ |
Promise在resolve语句后面,再抛出错误,不会被捕获,等于没有抛出。因为Promise的状态一旦改变,就永久保持该状态,不会再变了。
Promise对象的错误具有“冒泡”性质,会一直向后传递,直到被捕获为止。也就是说,错误总是会被下一个catch语句捕获。
1 | getJSON('/post/1.json').then(function(post) { |
一共有三个Promise对象:一个由getJSON产生,两个由then产生。他们之中任何一个抛出的错误,都会被最后一个catch捕获。
一般来说,不建议在then方法里面定义Reject状态的回调函数(即then的第二个参数),总是使用catch方法。
1 | // bad |
第二种写法要好于第一种写法,理由是第二种写法可以捕获前面then方法执行中的错误,也更接近同步的写法(try/catch)。因此,建议总是使用catch方法,而不使用then方法的第二个参数。
跟传统的try/catch代码块不同的是,如果没有使用catch方法指定错误处理的回调函数,Promise对象抛出的错误不会传递到外层代码,即不会有任何反应。
1 | const someAsyncThing = function() { |
someAsyncThing函数产生的Promise对象,内部有语法错误。浏览器运行到这一行,会打印出错误提示:ReferenceError:x is not defined,但不会退出进程、终止脚本执行,2秒后还是会输出123.这就是说,Promise内部的错误不会影响到Promise外部的代码,通俗的说法就是“Promise会吃掉错误”。
这个脚本放在服务器执行,退出码就是0(即表示执行成功)。不过Node有一个unhandledRejection事件,专门监听未捕获的reject错误,上面的脚本会触发这个事件的监听函数,可以在监听函数里面抛出错误。
1 | promise.on("unhandledRejection",function(err,p){ |
unhandledRejection事件的监听函数有两个参数,第一个是错误对象,第二个是报错的Promise实例,它可以用来了解发生错误的环境信息。
Node有计划在未来废除unhandledRejection事件。如果Promise内部有未捕获的错误,会直接终止进程,并且进程的退出码不为0。
1 | const promise = new Promise(function (resolve, reject) { |
Promise指定在下一轮“事件循环”再抛出错误。到了这个时候,Promise的运行已经结束了,所以这个错误是在Promise函数体外抛出的,会冒泡到最外层,成了未捕获的错误。
一般总是建议Promise对象后面要跟catch方法,这样可以处理Promise内部发生的错误。catch方法返回的还是一个Promise对象,因此后面还可以接着调用then方法。
1 | const someAsyncThing = function() { |
代码运行结束catch方法指定的回调函数,会接着运行后面那个then方法指定的回调函数。如果没有报错,则会跳过catch方法。
1 | Promise.resolve() |
上面的代码中因为没有报错,跳过了catch方法,直接执行后面的then方法。此时要是then方法里面报错,就与前面的catch无关了。
catch方法之中还能再抛出错误。
1 | const someAsyncThing = function() { |
上面的代码中,catch方法抛出一个错误,因为后面没有别的catch方法了,导致这个错误不会被捕获,也不会传递到外层。
1 | someAsyncThing().then(function() { |
上面的代码中,第二个catch方法用来捕获前一个catch方法抛出的错误。
Promise.prototype.finally()
finally方法用于指定不管Promise对象最后状态如何,都会执行的操作。该方法是ES2018引入标准的。
1 | promise.then(result=>{...}) |
不管Promise最后的状态,在执行完then或catch指定的回调函数以后,都会执行finally方法指定的回调函数。
服务器使用Promise处理请求,然后使用finally方法关掉服务器。
1 | server.listen(post) |
finally方法的回调函数不接受任何参数,这意味着没有办法知道,前面的Promise状态到底是fulfilled还是rejected。这表明finally方法里面的操作,应该是与状态无关的,不依赖于Promise的执行结果。
finally本质上是then方法的特例。
1 | promise.finally(()=>{ |
如果不使用finally方法,同样的语句需要为成功和失败两种情况各写一次。有了finally方法,则只需要写一次。
1 | Promise.prototype.finally = function(callback){ |
上面的代码中,不管前面的Promise是fulfilled还是rejected,都会执行回调函数callback。finally方法总是会返回原来的值。
1 | // resolve 的值是 undefined |
Promise.all()
Promise.all()方法用于将多个Promise实例,包装成一个新的Promise实例。
1 | const p = Promise.all([p1,p2,p3]); |
Promise.all()方法接受一个数组作为参数,p1、p2、p3都是Promise实例,如果不是则会先调用Promise.resolve方法,将参数转为Promise实例,再进行处理。另外,Promise.all()方法的参数可以不是数组,但必须具有Iterator接口,且返回的每个成员都是Promise实例。
p的状态由p1、p2、p3决定,分成两种情况:
- 只有p1、p2、p3的状态都变成fulfilled,p的状态才会变成fulfilled,此时p1、p2、p3的返回值组成一个数组,传递给p的回调函数。
- 只要p1、p2、p3之中有一个被rejected,p的状态就变成rejected,此时第一个被reject的实例的返回值,会传递给p的回调函数。
1 | const promises = [2,3,5,7,11,13].map(function(id){ |
promises是包含6个Promise实例的数组,只有这6个实例的状态都变成fulfilled,或者其中有一个变为rejected,才会调用Promise.all
方法后面的回调函数。
1 | const databasePromise = connectDatabase(); |
booksPromise
和userPromise
是两个异步操作,只有等到它们的结果都返回了,才会触发pickTopRecommendations
这个回调函数。
注意,如果作为参数的 Promise 实例,自己定义了catch
方法,那么它一旦被rejected
,并不会触发Promise.all()
的catch
方法。
1 | const p1 = new Promise((resolve, reject) => { |
p1
会resolved
,p2
首先会rejected
,但是p2
有自己的catch
方法,该方法返回的是一个新的 Promise 实例,p2
指向的实际上是这个实例。该实例执行完catch
方法后,也会变成resolved
,导致Promise.all()
方法参数里面的两个实例都会resolved
,因此会调用then
方法指定的回调函数,而不会调用catch
方法指定的回调函数。
如果p2
没有自己的catch
方法,就会调用Promise.all()
的catch
方法。
1 | const p1 = new Promise((resolve, reject) => { |
Promise.race()
Promise.race()
方法同样是将多个Promise实例包装成一个新的Promise实例。
1 | const p = Promise.race([p1,p2,p3]); |
只要p1,p2,p3之中有一个实例率先改变状态,p的状态也会跟着改变。那个率先改变的Promise实例的返回值,就传递给p的回调函数。
Promise.race()
方法的参数与Promise.all()
方法一样,如果不是 Promise 实例,就会先调用下面讲到的Promise.resolve()
方法,将参数转为 Promise 实例,再进一步处理。
如果指定时间内没有获得结果,就将 Promise 的状态变为reject
,否则变为resolve
。
1 | const p = Promise.race([ |
如果 5 秒之内fetch
方法无法返回结果,变量p
的状态就会变为rejected
,从而触发catch
方法指定的回调函数。
Promise.allSettled()
Promise.allSettled()
方法接受一组 Promise 实例作为参数,包装成一个新的 Promise 实例。只有等到所有这些参数实例都返回结果,不管是fulfilled
还是rejected
,包装实例才会结束。
1 | const promises = [ |
上面代码对服务器发出三个请求,等到三个请求都结束,不管请求成功还是失败,加载的滚动图标就会消失。
该方法返回的新的 Promise 实例,一旦结束,状态总是fulfilled
,不会变成rejected
。状态变成fulfilled
后,Promise 的监听函数接收到的参数是一个数组,每个成员对应一个传入Promise.allSettled()
的 Promise 实例。
1 | const resolved = Promise.resolve(42); |
上面代码中,Promise.allSettled()
的返回值allSettledPromise
,状态只可能变成fulfilled
。它的监听函数接收到的参数是数组results
。该数组的每个成员都是一个对象,对应传入Promise.allSettled()
的两个 Promise 实例。每个对象都有status
属性,该属性的值只可能是字符串fulfilled
或字符串rejected
。fulfilled
时,对象有value
属性,rejected
时有reason
属性,对应两种状态的返回值。
下面是返回值用法的例子。
1 | const promises = [ fetch('index.html'), fetch('https://does-not-exist/') ]; |
有时候,我们不关心异步操作的结果,只关心这些操作有没有结束。这时,Promise.allSettled()
方法就很有用。如果没有这个方法,想要确保所有操作都结束,就很麻烦。Promise.all()
方法无法做到这一点。
1 | const urls = [ /* ... */ ]; |
上面代码中,Promise.all()
无法确定所有请求都结束。想要达到这个目的,写起来很麻烦,有了Promise.allSettled()
,这就很容易了。
Promise.any()
Promise.any()
方法接受一组 Promise 实例作为参数,包装成一个新的 Promise 实例。只要参数实例有一个变成fulfilled
状态,包装实例就会变成fulfilled
状态;如果所有参数实例都变成rejected
状态,包装实例就会变成rejected
状态。该方法目前是一个第三阶段的提案 。
Promise.any()
跟Promise.race()
方法很像,只有一点不同,就是不会因为某个 Promise 变成rejected
状态而结束。
1 | const promises = [ |
上面代码中,Promise.any()
方法的参数数组包含三个 Promise 操作。其中只要有一个变成fulfilled
,Promise.any()
返回的 Promise 对象就变成fulfilled
。如果所有三个操作都变成rejected
,那么就会await
命令就会抛出错误。
Promise.any()
抛出的错误,不是一个一般的错误,而是一个 AggregateError 实例。它相当于一个数组,每个成员对应一个被rejected
的操作所抛出的错误。下面是 AggregateError 的实现示例。
1 | new AggregateError() extends Array -> AggregateError |
捕捉错误时,如果不用try...catch
结构和 await 命令,可以像下面这样写。
1 | Promise.any(promises).then( |
下面是一个例子。
1 | var resolved = Promise.resolve(42); |
Promise.resolve()
有时需要将现有对象转为 Promise 对象,Promise.resolve()
方法就起到这个作用。
1 | const jsPromise = Promise.resolve($.ajax('/whatever.json')); |
上面代码将 jQuery 生成的deferred
对象,转为一个新的 Promise 对象。
Promise.resolve()
等价于下面的写法。
1 | Promise.resolve('foo') |
Promise.resolve
方法的参数分成四种情况。
(1)参数是一个 Promise 实例
如果参数是 Promise 实例,那么Promise.resolve
将不做任何修改、原封不动地返回这个实例。
(2)参数是一个thenable
对象
thenable
对象指的是具有then
方法的对象,比如下面这个对象。
1 | let thenable = { |
Promise.resolve
方法会将这个对象转为 Promise 对象,然后就立即执行thenable
对象的then
方法。
1 | let thenable = { |
上面代码中,thenable
对象的then
方法执行后,对象p1
的状态就变为resolved
,从而立即执行最后那个then
方法指定的回调函数,输出 42。
(3)参数不是具有then
方法的对象,或根本就不是对象
如果参数是一个原始值,或者是一个不具有then
方法的对象,则Promise.resolve
方法返回一个新的 Promise 对象,状态为resolved
。
1 | const p = Promise.resolve('Hello'); |
上面代码生成一个新的 Promise 对象的实例p
。由于字符串Hello
不属于异步操作(判断方法是字符串对象不具有 then 方法),返回 Promise 实例的状态从一生成就是resolved
,所以回调函数会立即执行。Promise.resolve
方法的参数,会同时传给回调函数。
(4)不带有任何参数
Promise.resolve()
方法允许调用时不带参数,直接返回一个resolved
状态的 Promise 对象。
所以,如果希望得到一个 Promise 对象,比较方便的方法就是直接调用Promise.resolve()
方法。
1 | const p = Promise.resolve(); |
上面代码的变量p
就是一个 Promise 对象。
需要注意的是,立即resolve()
的 Promise 对象,是在本轮“事件循环”(event loop)的结束时执行,而不是在下一轮“事件循环”的开始时。
1 | setTimeout(function () { |
上面代码中,setTimeout(fn, 0)
在下一轮“事件循环”开始时执行,Promise.resolve()
在本轮“事件循环”结束时执行,console.log('one')
则是立即执行,因此最先输出。
Promise.reject()
Promise.reject(reason)
方法也会返回一个新的 Promise 实例,该实例的状态为rejected
。
1 | const p = Promise.reject('出错了'); |
上面代码生成一个 Promise 对象的实例p
,状态为rejected
,回调函数会立即执行。
注意,Promise.reject()
方法的参数,会原封不动地作为reject
的理由,变成后续方法的参数。这一点与Promise.resolve
方法不一致。
1 | const thenable = { |
上面代码中,Promise.reject
方法的参数是一个thenable
对象,执行以后,后面catch
方法的参数不是reject
抛出的“出错了”这个字符串,而是thenable
对象。
Promise.try()
实际开发中,经常遇到一种情况:不知道或者不想区分,函数f
是同步函数还是异步操作,但是想用 Promise 来处理它。因为这样就可以不管f
是否包含异步操作,都用then
方法指定下一步流程,用catch
方法处理f
抛出的错误。一般就会采用下面的写法。
1 | Promise.resolve().then(f) |
上面的写法有一个缺点,就是如果f
是同步函数,那么它会在本轮事件循环的末尾执行。
1 | const f = () => console.log('now'); |
上面代码中,函数f
是同步的,但是用 Promise 包装了以后,就变成异步执行了。
那么有没有一种方法,让同步函数同步执行,异步函数异步执行,并且让它们具有统一的 API 呢?回答是可以的,并且还有两种写法。第一种写法是用async
函数来写。
1 | const f = () => console.log('now'); |
上面代码中,第二行是一个立即执行的匿名函数,会立即执行里面的async
函数,因此如果f
是同步的,就会得到同步的结果;如果f
是异步的,就可以用then
指定下一步,就像下面的写法。
1 | (async () => f())() |
需要注意的是,async () => f()
会吃掉f()
抛出的错误。所以,如果想捕获错误,要使用promise.catch
方法。
1 | (async () => f())() |
第二种写法是使用new Promise()
。
1 | const f = () => console.log('now'); |
上面代码也是使用立即执行的匿名函数,执行new Promise()
。这种情况下,同步函数也是同步执行的。
鉴于这是一个很常见的需求,所以现在有一个提案,提供Promise.try
方法替代上面的写法。
1 | const f = () => console.log('now'); |
事实上,Promise.try
存在已久,Promise 库Bluebird
、Q
和when
,早就提供了这个方法。
由于Promise.try
为所有操作提供了统一的处理机制,所以如果想用then
方法管理流程,最好都用Promise.try
包装一下。这样有许多好处,其中一点就是可以更好地管理异常。
1 | function getUsername(userId) { |
上面代码中,database.users.get()
返回一个 Promise 对象,如果抛出异步错误,可以用catch
方法捕获,就像下面这样写。
1 | database.users.get({id: userId}) |
但是database.users.get()
可能还会抛出同步错误(比如数据库连接错误,具体要看实现方法),这时你就不得不用try...catch
去捕获。
1 | try { |
上面这样的写法就很笨拙了,这时就可以统一用promise.catch()
捕获所有同步和异步的错误。
1 | Promise.try(() => database.users.get({id: userId})) |
事实上,Promise.try
就是模拟try
代码块,就像promise.catch
模拟的是catch
代码块。