1.基本概念:
Promise是JS异步编程中的重要概念, 异步抽象处理对象,是目前比较流行Javascript异步编程解决方案之一
2.Promise的三种状态:
pending:对象初始化状态
fulfilled:当调用resolve(成功),会由pending => fulfilled
rejected:当调用reject(失败),会由pending => rejected
3.创建Promise
3.1 new Promise(resolve, reject);
const promise = new Promise((resolve, reject) => {
resolve('fulfilled'); // 状态由 pending => fulfilled
//reject('rejected'); // 状态由 pending => rejected
});
//then 在Promise 状态发生改变时触发
promise.then(result => { // onFulfilled resolve被调用会进入
console.log(result); },
reason => { // onRejected ,reject被调用会进入
})
3.2 Promise的静态方法创建
3.2.1 Promise.resolve() 返回一个fulfilled状态的promise对象
3.2.2 Promise.reject() 返回一个rejected状态的promise对象
Promise.reject() 不管传给它什么值,它会直接把这个值传递给错误回调函数。
Promise.resolve() 如何执行取决于传递的参数。
1)传普通类型(数值等)
let p1 = new Promise(resolve => {
resolve('成功');
})
//和上面是等价的
let p2 = Promise.resolve('成功'); //会直接决议为成功并把这个值传递过去
2)Promise类型:
let param = new Promise( resolve =>{
resolve('----resolve----')
})
//直接返回传递进去的promise
let p = Promise.resolve(param); //直接将param实例返回给了p
p.then(data => {console.log(data)}) //后打印结果为----resolve----
console.log( p === param) //打印true,虽然在p.then的下方但是由于Promise异步执行会先打印打印true
3) 传递一个thenable对象
let obj = { //obj是一个thenable对象
then(callback){
console.log('-----then---------');
callback('-------callback-----')
},
other(){
console.log('--------other---------') //不打印
}
}
Promise.resolve(obj)
执行结果:
Promise.resolve(obj).then(data => {
console.log(data)
})
执行结果:
结论:传进含有then方法的对象时,会立即执行then方法,如果then方法中有回调的时候也会执行(callback(‘-------callback-----’) 会被当成参数去替换 then(data => {
console.log(data)
}) 中的data, 在调用then()时被执行)
resolve(data)的参数会被当做then(data)的参数执行。
如果理解有偏差,请大家多多指正。
4.异步在ES6的应用
ES6 中新加入了 async,await 两个语法糖支持异步
**async:**注明这个方法是异步方法,方法返回值会被包装成promise对象。
**await:**只能在async标注的方法里面使用,用于同步等待异步方法返回,如果抛出异常需要用try catch接收
1)await 接收抛出异常的异步方法
async test() {
throw new Error('出现异常')
},
async test2(){
try {
let a = await this.test()
console.log('data:' + JSON.stringify(a))
} catch (e) {
console.error('异常被捕获')
}
}
运行 test2() 测试结果:
2)await 接收正常返回的异步方法
async test() {
return {
id: 1,
age: 2
}
},
结果:
3)不使用await接收抛出异常的async 方法
async test2() {
const a = this.test()
console.log('-----------执行前 a:-------------', JSON.stringify(a))
a.then(data => {
console.log('data:' + JSON.stringify(data))
}).catch(e => {
console.error(' test2:', e)
})
},
async test() {
throw new Error('异常')
return {
id: 1,
age: 2
}
},
结果:
异步返回值为promise对象且状态为 rejected,然后被catch方法捕获
4)不使用await接收正常返回的async 方法
async test() {
return {
id: 1,
age: 2
}
},
结果:
返回了promise 对象状态为fulfilled 触发then方法。
- await 只会阻塞async 修饰的方法里面的执行,并不会阻塞主线程,test() 和test2() 方法里面是阻塞的,test3() 方法没有被阻塞。
async function test() {
console.log( await wait(200))
console.log('111111')
}
async function test2() {
console.log( await wait(1000))
console.log('222222222')
}
function wait(ms) {
return new Promise(resolve => { setTimeout(() => resolve(123 + ms), ms)
})
}
function test3(){
test2()
test()
console.log("123")
}
test3()
VM805:19 123
undefined
VM805:2 323
VM805:3 111111
VM805:7 1123
VM805:8 222222222