1、概述
Promise 是异步编程的一种解决方案,比传统的解决方案——回调函数和事件——更合理和更强大。所谓的 Promise
,简单说就是一个容器,里面保存着某个未来才会结束的事件的结果(通常是一种异步操作)。
Promise 对象的两个特点:
(1)对象的状态不受外界的影响。Promise
对象代表一个异步操作,有三种状态:Pending
(进行中)、Fulfilled
(已成功)、Rejected
(已失败)。只有异步操作的结果,可以决定当前是哪种状态,任何其他操作都无法改变这个状态。
(2)一旦状态改变,就不会再变,任何时候都可以得到这个结果。Promise 对象的状态改变只有两种可能:Pending
-> Fulfilled
;Pending
-> Rejected
。只要这两种情况发生,状态就凝固了,不会再变了,会一直保持这个结果,这个就称为 Resolved(已定型)。如果改变已经发生了,你再对 Promsise
对象添加回调函数,也会立即得到这个结果。这与事件(Event)完全不同,事件的特点是,如果你错过了它,再去监听,是得不到结果的。
var p1 = new Promise(function(resolve, reject){
resolve('ok');
return reject(new Error("err"));
});
p1
.then(() => console.log("success"))
.catch((err)=> console.log(err));
// 输出 success ,
// 因为 Promise 的状态一旦改变,就永久保持该状态,不会在改变,
// 所以在 `resolve` 后面再抛出错误,不会被捕获,等于没有抛出。
Promise 缺点:
(1)无法取消 Promise
对象,一旦新建它就会立即执行,无法中途取消。
(2)如果不设置回调函数,Promise
内部抛出的错误,不会反应到外部。
(3)当处于 Pending
状态时,无法得知目前进展到哪一阶段(刚开始还是即将完成)。
2、基本用法
ES6 规定, Promise
对象是一个构造函数,用来生成 Promise
实例。
var promise = new Promise(function(resolve, reject){
if(/**异步操作成功*/){
resolve(value);
} else {
reject(err);
}
});
从上述代码可以看到, Promise
构造函数接受一个函数作为参数,该函数有两个参数分别为 resolve
和 reject
。它们是两个函数,由 JavaScript 引擎提供,不用自己部署。
- resolve
函数的作用是将 Promise
对象的状态从“未完成”变为“成功”(即 Pending
-> Fulfilled
),在异步操作成功时调用,并将异步操作的结果,作为参数传递出去。参数为可选,且参数除了可以是正常值外还可以是另一个 Promise 对象。
- reject
函数的作用是将 Promise
对象的状态从“未完成”变为“失败”(即Pending
-> Rejected
),在异步操作失败时调用,并将异步操作报出的错误,作为参数传递出去。参数为可选,通常为 Erro
对象的实例,表示抛出的错误。
注意:
(1)Promise 新建后就会立即执行。
(2)当resolve
的参数为 Promise 对象时,此时原有 Promise 对象的状态由 参数 Promise 对象的状态决定。
var p1 = new Promise(function(resolve, reject){
setTimeout(() => reject(new Error('fail')),3000);
});
var p2 = new Promise(function(resolve, reject){
setTimeout(() => resolve(p1), 1000);
});
p2
.then(result => console.log(result))
.catch(error => console.log(error)); => Error: fail
上面代码中,p1
是一个 Promise,3 秒之后变为 rejected
。p2
的状态在 1 秒后改变, resolve
方法返回的是 p1
。 由于 p2
返回的是另一个 Promise ,导致, p2
自己的状态无效,由 p1
的状态决定 p2
的状态。所以,后面 then
语句变为针对 p1
。又过了 2 秒, p1
变为 rejected
,导致触发了 catch
方法指定的回调函数。
(3)调用 resolve
或 reject
并不会终结 Promise 的参数函数的执行,即 resolve
或 reject
的后续代码依然会执行。并且,后续代码是在 then
或 catch
方法之前执行,这是因为立即 resolved 的 Promise 是在本轮时间循环的末尾执行,总是晚于本轮循环的同步任务,即当前脚本所有同步任务执行完成才会执行。
(4)一般来说,调用 resolve
或 reject
以后,Promise 的使命就完成了,后续操作应该放到 then
方法中,而不是直接写在 resolve
或 reject
之后。并且最好在它们前面加上 return
。
3、Promise.prototype.then()
Promise 的 then
方法定义在原型对象 Promise.prototype
上。它的作用是为 Promise 实例添加状态改变时的回调函数。
- 该方法有两个参数,第一个为 Resolved 状态的回调函数,第二个参数(可选)为 Rejected 状态的回调函数。函数的参数分别接受来自 Promise
函数中的 resolve
和 reject
的参数。
- then
方法返回的是一个新的 Promise 实例(注意,不是原来那个 Promise 实例)。因此可以采用链式写法,即 then
方法后面再调用另一个 then
方法。
var p1 = new Promise(function(resolve, reject){
return resolve();
});
p1
.then(() => p1, () => console.log("fail"))
.then(() => console.log("success"));
注意:
一般来说,不要在 then
方法里面定义 Rejected 状态的回调(即 then
的第二个参数),而是使用下面 catch
方法。
前一个 then 方法的 return 值是后一个 then 方法回调函数的参数。
4、Promise.prototype.catch()
Promise 的 catch
方法定义在原型对象 Promise.prototype
上。用于指定发生错误时的回调函数。
var p1 = new Promise(function(resolve, reject){
throw new Error('err');
});
p1.catch(function(err){
console.log(err);
});
注意:
(1)Promise 对象的错误具有“冒泡”性质,会一直往后传,直到被捕获为止,也就是说,错误总会被下一个 catch
语句捕获。
(2)then
方法中的第二参数,只能捕获到它前一个 Promise 对象产生的错误,而 catch
语句可以捕获到前面所有 Promise 对象抛出的错误。因此不建议在 then
方法中写第二个参数来捕获错误。
var p1 = new Promise(function(resolve, reject){
resolve();
});
p1
.then(() => {throw new Error('err')},()=> console.log("fail"))
.then(() => console.log("success"))
.catch((err)=> console.log(err));
// 输出 Error: err,为 catch 语句输出。
上述代码,then
方法中的第二个参数只能捕获,p1 中抛出的异常,而 catch 可以捕获到 由两个 then
产生的 Promise 对象的异常,(如果第一个 then
中没有第二个参数,也能补捕获到 p1 参数的异常,因为异常只能被捕获一次)。
(3)如果没有定义任何错误处理的回调函数, Promise 对象抛出的错误不会被捕获,也不会传递到外层代码,即不会有任何反应,正常情况下,运行后不会有任何输出,但是浏览器此时会打印出错误,不过不会终止脚本的运行,如果这个脚本放在服务器执行,退出码就是 0 (即表示成功)。
(4)Promise 运行结束后抛出的错误,不会被捕获。
var p1 = new Promise(function(resolve, reject){
resolve('ok');
setTimeout(function () { throw new Error('test') }, 0);
});
p1
.then(() => console.log("success"))
.catch((err) => console.log(err));
// 输出 success 后,浏览器打印出错误(不是被 catch 捕获到的)
上述代码,Promise 指定在下一轮“事件循环”再抛出错误,到了那个时候, Promise 的运行已经结束了,所以在这个错误是在 Promise 函数体外抛出,会冒泡到最外层。
(5)catch
方法返回的还是一个 Promise 对象,因此后面还可以接着调用 then
和 catch
方法。
5、Promise.resolve()
Promise.resolve
方法是将现有对象转为 Promise 对象。
Promise.resolve('foo') => new Promise(resolve => resolve('foo'))
Promise.resolve 方法参数分为四种情况:
(1)参数是一个 Promise 对象。此时,该方法不做任何修改,原封不动的返回这个实例。
(2)参数是一个 thenable
对象。thenable
对象指的是具有 then
方法的的对象,如:
let thenable = {
then: function(resolve, reject){
resolve(42);
}
};
Promise.resolve
方法会将这个对象转为 Promise 对象,然后就立即执行 thenable
的 then
方法。
let p1 = Promise.resolve(thenable); // 立即执行 thenable 中的 then 方法。
p1.then(value => console.log(value)); // 输出 42
(3)参数不是具有 then
方法的对象,或根本就不是对象。
如果参数是一个原始值,或者一个不具有 then
方法的对象,则Promise.resolve
方法返回一个新的 Promise 对象,状态为 Resolved
。 Promise.resolve
方法的参数,会同时传给回调函数。
(4)不带有任何参数。此时直接返回一个状态为 Resolved
的 Promise 对象。
注意:立即 resolve
的 Promise 对象,是在本轮“事件循环”的结束时,而不是在下一轮“事件循环”的开始是。
let thenable = {
then: function(resolve, reject){
console.log('two');
resolve();
}
};
setTimeout( () => console.log("four"), 0);
Promise.resolve(thenable).then(() => console.log('three'));
console.log('one');
// 输出 one two three four
上述代码中,setTimeout(f, 0)
在下一轮“事件循环”开始时执行;Promise.resolve()
在本轮“事件循环”结束时执行; console.log('one')
则是立即执行。
6、Promise.all()
Promise.all
方法用于将多个 Promise 实例,包装成一个新的 Promise 实例。
var p = Promise.all([p1, p2, p3]);
Promise.all
方法接受一个数组作为参数。p1
、 p2
、 p3
都是 Promise 实例,如果不是,就会先调用 Promise.resolve
方法,将参数转为 Promise 实例,再进一步处理。
p
的状态由 p1
、 p2
、 p3
决定,分两种情况:
(1)只有 p1
、 p2
、 p3
的状态都变为 fulfilled
,p
的状态才会变为 fulfilled
,此时 p1
、 p2
、 p3
的返回值组成一个数组,传递给 p
的回调函数。
(2)只要 p1
、 p2
、 p3
之中有一个被 Rejected
,p
的状态就变为 Rejected
,此时,第一个被 reject
的实例的返回值,会传递给 p
的回调函数。
注意:
(1)Promise.all
方法的参数可以不是数组,但必须具有 Iterator 接口,且返回的每个成员都是 Promise 实例。
(2)如果作为参数的 Promise 实例,自己定义了 catch
方法,那么它一旦被 reject
,并不会触发 Promise.all
的 catch
方法。如果没有自己定义 catch
方法,就会调用 Promise.all
的 catch
方法。
const p1 = new Promise((resolve, reject) => {
resolve('hello');
})
.then(result => result)
.catch(e => e);
const p2 = new Promise((resolve, reject) => {
throw new Error('报错了');
})
.then(result => result)
.catch(e => e);
Promise.all([p1, p2])
.then(result => console.log(result))
.catch(e => console.log(e));
// ["hello", Error: 报错了]
----------------------------------------------------------
const p1 = new Promise((resolve, reject) => {
resolve('hello');
})
.then(result => result);
const p2 = new Promise((resolve, reject) => {
throw new Error('报错了');
})
.then(result => result);
Promise.all([p1, p2])
.then(result => console.log(result))
.catch(e => console.log(e));
// Error: 报错了
7、Promise.race()
Promise.race
方法用于将多个 Promise 实例,包装成一个新的 Promise 实例。
var p = Promise.race([p1, p2, p3])
Promise.race
方法的参数与 Promise.all
方法一样。不同的是状态改变机制。
只要 p1
、 p2
、 p3
之中有一个实例率先改变状态,p
的状态就跟着改变。那个率先改变的 Promise 实例的返回值,就传给 p
的回调函数。
8、Promise.reject()
Promise.reject(reason)
方法返回一个新的 Promise 实例,该实例状态为 rejected
。且方法的参数,会原封不动的作为 rejected
的理由,变成后续方法的参数。
9、两个很有用的附加方法
下面介绍如何部署两个不在 ES6 之中,但很有用的方法。
(1)done()
Promise 对象的回调链,不管以 then
方法或 catch
方法结尾,要是最后一个方法抛出错误,都无法捕捉到(因为 Promise 内部的错误不会冒泡到全局)。因此,我们可以提供一个 done
方法,总是处于回调链的尾端,保证捕捉到任何可能出现的错误,并向全局抛出。
Promise.prototype.done = function(onFulfilled,onRejected){
this.then(onFulfilled, onRejected)
.catch(function(reason){
setTimeout(() => {throw reason}, 0); // 抛出一个全局错误
});
};
p.then(f1)
.catch(r1)
.then(f2)
.done();
(2)finally()
finally
方法用于指定不管 Promise 对象最后状态如何,都会执行的操作。它与 done
方法的最大区别,它接受一个普通的回调函数作为参数,该函数不管怎样读必须执行。
Promise.prototype.finally = function (callback) {
let p = this.constructor;
return this.then(
value => p.resolve(callback()).then(() => value),
reason => p.resolve(callback()).then(() => {throw reason})
);
};
10、Promise.try()
Promise.try()
方法会让同步函数同步执行,异步函数异步执行,并且可以以使用 then
、 catch
方法。
Promise.try(func)
.then(...)
.catch(...)
11、then方法中的参数问题
var promiseTest = new Promise(function(resolve,reject){
resolve('resolve');
});
promiseTest.then(v => {
console.log(v); // resolve
return "return";
}).then(v => {
console.log(v); // return
var promise2 = Promise.resolve('promise2 resolve');
return promise2;
}).then(v => {
console.log(v); // promise2 resolve
});