1. 基本介绍
1.1 概念
Promise 是异步编程的一种解决方案,比传统的解决方案——回调函数和事件——更合理和更强大。
所以Promise,简单说就是一个容器,里面保存着某个未来才会结束的事件(通常是一个异步操作)的结果。
1.2 特点
- 对象的状态不受外界影响。
- 一旦状态改变,就不会再变,任何时候都可以得到这个结果
1.3 状态
Promise
对象代表一个异步操作,有三种状态:
pending(进行中)
fulfilled(已成功)
rejected(已失败)
只有异步操作的结果,可以决定当前是哪一种状态,任何其他操作都无法改变这个状态。
1.4 缺点
- 无法取消
Promise
,一旦新建它就会立即执行,无法中途取消。 - 如果不设置回调函数,
Promise
内部抛出的错误,不会反应到外部。 - 当处于
pending
状态时,无法得知目前进展到哪一个阶段(刚刚开始还是即将完成)。
注意,为了行文方便,本章后面的 resolved 统一只指 fulfilled 状态,不包含 rejected 状态
1.5 用法
写js
必然不会对异步事件陌生。
settimeout(()=>{
console.log("123")
},0)
console.log("abc")
// 先输出谁?
如果abc
需要在123
执行结束后再输出怎么办?
当然,可以使用callback
,但是callback
使用起来是一件很让人绝望的事情
这时,
Promise
这个为异步编程而生的对象站了出来....
let p = new Promise((resolve, reject) => {
settimeout(() => {
console.log("123")
resolve("abc");
}, 0)
}).then(function (data) {
// resolve状态
console.log(data)
}, function (err) {
// reject状态
})
// => '123'
// => 'abc'
这时候你应该有两个疑问:
- 包装这么一个函数有什么用?
-
resolve('123')
这是干什么的?
Promise
实例生成以后,可以用then
方法分别指定resolved
状态和rejected
状态的回调函数
也就是说,状态由实例化时的参数(函数)执行来决定的,根据不同的状态,看看需要走then
的第一个参数还是第二个。
resolve()
和reject(
)的参数会传递到对应的回调函数的data
或err
then
返回的是一个新的Promise
实例,也就是说可以继续then
2. 链式操作的用法
所以,从表面上看,Promise
只是能够简化层层回调的写法,而实质上,Promise
的精髓是“状态”,用维护状态、传递状态的方式来使得回调函数能够及时调用,它比传递callback
函数要简单、灵活的多。所以使用Promise
的正确场景是这样的:
runAsync1()
.then(function (data) {
console.log(data);
return runAsync2();
})
.then(function (data) {
console.log(data);
return runAsync3();
})
.then(function (data) {
console.log(data);
});
// => 异步任务1执行完成
// => 随便什么数据1
// => 异步任务2执行完成
// => 随便什么数据2
// => 异步任务3执行完成
// => 随便什么数据3
runAsync1
、runAsync2
、runAsync3
长这样↓
function runAsync1() {
var p = new Promise(function (resolve, reject) {
// 做一些异步操作
setTimeout(function () {
console.log('异步任务1执行完成');
resolve('随便什么数据1');
}, 1000);
});
return p;
}
function runAsync2() {
var p = new Promise(function (resolve, reject) {
setTimeout(function () {
console.log('异步任务2执行完成');
resolve('随便什么数据2');
}, 2000);
});
return p;
}
function runAsync3() {
var p = new Promise(function (resolve, reject) {
setTimeout(function () {
console.log('异步任务3执行完成');
resolve('随便什么数据3');
}, 2000);
});
return p;
}
在then
方法中,你也可以直接return
数据而不是Promise
对象,在后面的then
中也可以接收到数据:
runAsync1()
.then(function (data) {
console.log(data);
return runAsync2();
})
.then(function (data) {
console.log(data);
return '直接返回数据'; //这里直接返回数据
})
.then(function (data) {
console.log(data);
});
// => 异步任务1执行完成
// => 随便什么数据1
// => 异步任务2执行完成
// => 随便什么数据2
// => 直接返回数据
3. reject
的用法
前面的例子都是只有“执行成功”的回调,还没有“失败”的情况,reject
的作用就是把Promise
的状态置为rejected
,这样我们在then
中就能捕捉到,然后执行“失败”情况的回调。
let num = 10;
let p1 = function () {
return new Promise((resolve, reject) => {
if (num <= 5) {
resolve("<=5,走resolve")
console.log('resolve不能结束Promise')
} else {
reject(">5,走reject")
console.log('reject不能结束Promise')
}
})
}
p1()
.then(function (data) {
console.log(data)
}, function (err) {
console.log(err)
})
// => reject不能结束Promise
// => >5,走reject
resolve
和reject
永远会在当前环境的最后执行,所以后面的同步代码会先执行。如果
resolve
和reject
之后还有代码需要执行,最好放在then
里。然后在
resolve
和reject
前面写上return
。
4. Promise.prototype.catch()
Promise.prototype.catch
方法是.then(null, rejection)
的别名,用于指定发生错误时的回调函数。
p1()
.then(function (data) {
console.log(data)
})
.catch(function (err) {
console.log(err)
})
// => reject不能结束Promise
// => >5,走reject
5. Promise.all()
Promise.all
方法用于将多个 Promise
实例,包装成一个新的 Promise
实例
const p = Promise.all([p1, p2, p3]);
p
的状态由p1
、p2
、p3
决定,分成两种情况。
- 只有
p1
、p2
、p3
的状态都变成fulfilled
,p
的状态才会变成fulfilled
。 此时p1
、p2
、p3
的返回值组成一个数组,传递给p
的回调函数。 - 只要
p1
、p2
、p3
之中有一个被rejected
,p
的状态就变成rejected
,此时第一个被reject
的实例的返回值,会传递给p
的回调函数。
promises
是包含 3 个 Promise
实例的数组,只有这 3 个实例的状态都变成fulfilled
,或者其中有一个变为rejected
,才会调用Promise.all
方法后面的回调函数。
如果作为参数的 Promise
实例,自己定义了catch
方法,那么它一旦被rejected
,并不会触发Promise.all()
的catch
方法,如果没有参数没有定义自己的catch
,就会调用Promise.all()
的catch
方法。
6. Promise.race()
Promise.race
方法同样是将多个 Promise
实例,包装成一个新的 Promise
实例。
const p = Promise.race([p1, p2, p3]);
上面代码中,只要p1
、p2
、p3
之中有一个实例率先改变状态,p
的状态就跟着改变。那个率先改变的 Promise
实例的返回值,就传递给p
的回调函数。
7. Promise.resolve()
有时需要将现有对象转为 Promise
对象,Promise.resolve
方法就起到这个作用。
const jsPromise = Promise.resolve('123');
上面代码将123
转为一个 Promise
对象。
Promise.resolve
等价于下面的写法。
Promise.resolve('123')
// 等价于
new Promise(resolve => resolve('123'))
-
参数是一个
Promise
实例如果参数是
Promise
实例,那么Promise.resolve
将不做任何修改、原封不动地返回这个实例。 -
参数是一个
thenable
对象thenable
对象指的是具有then
方法的对象,比如下面这个对象。let thenable = { then: function (resolve, reject) { resolve(42); } };
Promise.resolve
方法会将这个对象转为 Promise 对象,然后就立即执行thenable
对象的then
方法。let thenable = { then: function (resolve, reject) { resolve(42); } }; let p1 = Promise.resolve(thenable); p1.then(function (value) { console.log(value); // => 42 });
上面代码中,
thenable
对象的then
方法执行后,对象p1
的状态就变为resolved
,从而立即执行最后那个then
方法指定的回调函数,输出 42。 -
参数不是具有
then
方法的对象,或根本就不是对象如果参数是一个原始值,或者是一个不具有
then
方法的对象,则Promise.resolve
方法返回一个新的Promise
对象,状态为resolved
const p = Promise.resolve('Hello'); p.then(function (s){ console.log(s) }); // => Hello
上面代码生成一个新的
Promise
对象的实例p
。由于字符串Hello
不属于异步操作(判断方法是字符串对象不具有then
方法),返回Promise
实例的状态从一生成就是resolved
,所以回调函数会立即执行。Promise.resolve
方法的参数,会同时传给回调函数。 -
不带有任何参数
Promise.resolve
方法允许调用时不带参数,直接返回一个resolved
状态的 Promise 对象所以,如果希望得到一个 Promise 对象,比较方便的方法就是直接调用
Promise.resolve
方法const p = Promise.resolve(); p.then(function () { // ... });
上面代码的变量
p
就是一个Promise
对象。需要注意的是,立即
resolve
的Promise
对象,是在本轮“事件循环”(event loop
)的结束时,而不是在下一轮“事件循环”的开始时。setTimeout(function () { console.log('three'); }, 0); Promise.resolve().then(function () { console.log('two'); }); console.log('one'); // => one // => two // => three
上面代码中,
setTimeout(fn, 0)
在下一轮“事件循环”开始时执行,Promise.resolve()
在本轮“事件循环”结束时执行,console.log('one')
则是立即执行,因此最先输出。
8. 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
对象的实例p
,状态为rejected
,回调函数会立即执行
注意,Promise.reject()
方法的参数,会原封不动地作为reject
的理由,变成后续方法的参数。这一点与Promise.resolve
方法不一致。
const thenable = {
then(resolve, reject) {
reject('出错了');
}
};
Promise.reject(thenable)
.catch(e => {
console.log(e === thenable)
})
// => true
上面代码中,Promise.reject
方法的参数是一个thenable
对象,执行以后,后面catch
方法的参数不是reject
抛出的“出错了”这个字符串,而是thenable
对象。