- Promise summary
- 异步操作, 装载着预定成功或失败时要执行的回调函数.
- 有三种状态: pending, fulfilled, rejected. 且状态不受外界影响;
- 状态变化有两种: pending->fulfilled, pending->rejected, 且状态改变后不会再变化.
- 无法取消 Promise;
- 不设置回调函数(成功的, 失败的), 不会反应到外部;
- pending 时, 无法得知进度.
- Usage
- ES6 规定,Promise 对象是一个构造函数,用来生成 Promise 实例。
const promise = new Promise(function(resolve, reject) {
// ... some code
if (/* 异步操作成功 */){
resolve(value);
} else {
reject(error);
}
});
- Promise 实例生成以后,可以用 then 方法分别指定 resolved 状态和 rejected 状态的回调函数。
promise.then(
function(value) {
// success
},
function(error) {
// failure
}
);
function timeout(ms) {
return new Promise((resolve, reject) => {
setTimeout(resolve, ms, 'done');
});
}
timeout(100).then(value => {
console.log(value);
});
- Promise 执行过程请注意: Promise 新建后立即执行,
then
方法指定的回调函数(它是异步的),将在当前脚本所有同步任务
执行完才会执行
- Promise.prototype.then()
then
方法返回的是一个新的Promise
实例(注意,不是原来那个Promise
实例), 因此可以采用链式写法,即then
方法后面再调用另一个then
方法。
- Promise.prototype.catch()
- Promise.prototype.catch 方法是.then(null, rejection)或.then(undefined, rejection)的别名,用于指定发生错误时的回调函数。
let promise = new Promise(function(resolve, reject) {
reject('do reject test');
});
promise
.then(function() {
console.log('resolved.');
})
.catch(function(error) {
console.log(error, 'catchchain');
});
promise.catch(function(error) {
console.log(error, 'catch');
});
// console log:
// do reject test catch
// do reject test catchchain
// ====
let promise = new Promise(function(resolve, reject) {
reject('do reject test');
});
promise
.then(
function() {
console.log('resolved.');
},
function(error) {
console.log(error, 'catchinner');
}
)
.catch(function(error) {
console.log(error, 'catchchain');
}); //此处的catch将不起作用.
promise.catch(function(error) {
console.log(error, 'catch');
});
// console log:
// do reject test catchinner
// do reject test catch
一般来说,不要在then方法里面定义 Reject 状态的回调函数(即then的第二个参数),总是使用catch方法。
- Promise 内部的错误不会影响到 Promise 外部的代码,通俗的说法就是“Promise 会吃掉错误”。
一般总是建议,Promise 对象后面要跟catch方法,这样可以处理 Promise 内部发生的错误。catch方法返回的还是一个 Promise 对象,因此后面还可以接着调用then方法。
- Promise.prototype.finally()
finally
方法用于指定不管 Promise 对象最后状态如何,都会执行的操作。该方法是 ES2018 引入标准的。
- Promise.all()
- Promise 实例的状态都变成
fulfilled
,或者其中有一个变为 rejected
,才会调用 Promise.all
方法后面的回调函数。
- 注意,如果作为参数的 Promise 实例,自己定义了
catch
方法,那么它一旦被rejected
,并不会触发Promise.all()
的catch
方法。
- Promise.race()
Promise.race()
方法同样是将多个 Promise 实例,包装成一个新的 Promise 实例。只要有一个先改变了状态, 就会执行回调函数then
或者异常catch
- Promise.allSettled()
Promise.allSettled()
方法接受一组 Promise 实例作为参数,包装成一个新的 Promise 实例。只有等到所有这些参数实例都返回结果,不管是 fulfilled
还是 rejected
,包装实例才会结束。该方法由 ES2020
引入。
- 有时候,我们不关心异步操作的结果,只关心这些操作有没有结束。这时,
Promise.allSettled()
方法就很有用。如果没有这个方法,想要确保所有操作都结束,就很麻烦。Promise.all()
方法无法做到这一点。
- Promise.any()
Promise.any()
方法接受一组 Promise 实例作为参数,包装成一个新的 Promise 实例。只要参数实例有一个变成fulfilled
状态,包装实例就会变成fulfilled
状态;如果所有参数实例都变成rejected
状态,包装实例就会变成rejected
状态。
Promise.any()
跟Promise.race()
方法很像,只有一点不同,就是不会因为某个 Promise 变成 rejected 状态而结束。
- Promise.resolve()
- 有时需要将现有对象转为 Promise 对象,
Promise.resolve()
方法就起到这个作用。
const jsPromise = Promise.resolve($.ajax('/whatever.json'));
// 上面代码将 jQuery 生成的deferred对象,转为一个新的 Promise 对象。
- Promise.resolve()等价于下面的写法。
Promise.resolve('foo');
// 等价于
new Promise(resolve => resolve('foo'));
- Promise.resolve 方法的参数分成四种情况。
- (1)参数是一个 Promise 实例
- 如果参数是 Promise 实例,那么
Promise.resolve
将不做任何修改、原封不动地返回这个实例。
- (2)参数是一个
thenable
对象
thenable
对象指的是具有 then
方法的对象,比如下面这个对象。
let thenable = {
then: function(resolve, reject) {
resolve(42);
},
};
Promise.resolve
方法会将这个对象转为 Promise 对象,然后就立即执行thenable
对象的then
方法。
- (3)参数不是具有
then
方法的对象,或根本就不是对象
Promise.resolve
方法返回一个新的 Promise 对象,状态为 resolved
。同时会把这个参数传给这之后then
的回调函数.
- (4)不带有任何参数
Promise.resolve()
方法允许调用时不带参数,直接返回一个 resolved
状态的 Promise 对象。
- 需要注意的是,立即
resolve()
的 Promise 对象,是在本轮“事件循环”(event loop)的结束时执行,而不是在下一轮“事件循环”的开始时。setTimeout(fn, 0)
在下一轮“事件循环”开始时执行
- Promise.reject()
Promise.reject(reason)
方法也会返回一个新的 Promise 实例,该实例的状态为 rejected
。
const p = Promise.reject('出错了');
// 等同于
const p = new Promise((resolve, reject) => reject('出错了'));
p.then(null, function(s) {
console.log(s);
});
// 出错了
- 注意,
Promise.reject()
方法的参数,会原封不动地作为 reject
的理由,变成后续方法的参数。这一点与 Promise.resolve
方法不一致。