js进阶--Promise-10

Promise

Promise是es6新增的一个类
用处：将异步代码，以同步的方式写出来，避免了回调地狱
使用的时候要new一下Promise

new的时候里面传一个函数，函数有两个形参,第一个代表成功，第二个代表失败

let p1=new Promise((resolve,reject)=>{
    resolve();//假设第一个函数执行
    reject();//第二个代表失败
});

Promise有三个状态

• pending等待态 fulfilled成功态 rejected失败态
• Promise在new的时候立即执行,如果不指定状态的话,默认为等待态pending
• 状态只能改变一次，要么pending–>fulfilled或者pending–>rejected
• 如果写了reject也写了resolve只执行前面的,因为状态只能改变一次

resolve代表成功执行，reject代表失败执行

then

实例.then()
then里面可以放两个函数，第一个是成功

p1.then(()=>{
    console.log("成功")
    // resolve执行，那这个就执行
},()=>{
    //reject执行，那这个就执行
    console.log("失败")
})

前面的.then里return如果不是promise实例的话，那么会把return的东西当实参传递给下一个.then

catch

catch是promise原型上的一个方法，当任何一个promise的实例是失败态的时候就会执行catch函数
如果回调函数执行的时候发生了错误，那当前promise的实例会默认为失败态
catch里面的形参会接受报错内容，或者失败态的实参

let p1=new Promise((resolve,reject)=>{
    console.log(a);
})
p1.then(()=>{
    console.log("成功态")
},()=>{
    console.log("失败态")
})//"失败态"

特殊情况
只要下面的then有失败态的函数，就先执行失败态的函数，没有才执行catch

let p1=new Promise((res,rej)=>{
    res();
});

p1.then((res)=>{
    console.log(res,100);
    return new Promise((res,rej)=>{
        rej(111);
    })
}).then(()=>{},()=>{})
.catch((res)=>{
    console.log(res,200);
}).finally(()=>{
    console.log("最后")
})
//undefined 100  111 200 最后

let p1=new Promise((res,rej)=>{
    res();
});

p1.then((res)=>{
    console.log(res,100);
    return new Promise((res,rej)=>{
        rej(111);
    })
}).then(()=>{},()=>{})
.catch((res)=>{
    console.log(res,200);
}).finally(()=>{
    console.log("最后")
})
//undefined 100 最后

let p1=new Promise((resolve,reject)=>{
    console.log(a);
})
p1.then(()=>{
    console.log("成功态")
},()=>{
    console.log(c)//让他出错
}).catch((aa)=>{console.log(aa,200)})//ReferenceError: c is not defined at <anonymous>:7:17 200

finally

除非为等待态，否则不论成功失败，都会执行finally
finally方法的回调函数不接受任何参数

let p1=new Promise((resolve,reject)=>{
    console.log(a);
})
p1.then(()=>{
    console.log("成功态")
},()=>{
    console.log("失败态")
}).catch((error)=>{console.log(error)}).finally(()=>{console.log(888)})//失败态 888

Promise.all([])

• all里面的数组可以放promise实例，等里面的全部执行完毕，会返回一个态度(成功态，或失败态),数组内全部成功all才返回成功态，有一个失败就位失败态
• 如果all为成功态，那么数组内所有promise的实例的返回值会传递给.then里面的成功态，如果失败，会把第一个失败的传参传递给.then里的失败态
  Promise.all的参数不一定是promise的实例，是别的值也可以，他内部会把当前的值转换成成功态的promise实例

let p1=new Promise((resolve,reject)=>{
    resolve(100);
})
let p2=new Promise((resolve,reject)=>{
    resolve(200);
})
let p3=new Promise((resolve,reject)=>{
    resolve(300);
})
const p=Promise.all([p1,p2,p3]);
p.then((res)=>{
    console.log(res,"成功态")// (3) [100, 200, 300] "成功态"
},(rej)=>{
    console.log("失败态")
})

Promise.race([])

[]里的promise实例中谁先执行完毕，那么这个先执行完成的是什么态那就是什么态(成功，失败，等待)，返回值也只接收这一个,如果为等待态，那么就不执行.then

let p1=new Promise((resolve,reject)=>{
    setTimeout(()=>{    resolve(100);},1000)
})
let p2=new Promise((resolve,reject)=>{
    // resolve(200);
    setTimeout(()=>{},100)
})
let p3=new Promise((resolve,reject)=>{
    // resolve(300);
})
const p=Promise.all([p1,p2,p3]);
p.then((res)=>{
    console.log(res,"成功态")
},(rej)=>{
    console.log("失败态")
})
//Promise {<pending>}

Promise.resolve()

他的返回值就是一个已经成功的promise的实例

let pp=Promise.resolve(100);
let pp=new Promise((res,rej)=>{
    res(100);
})
//两者相等

Promise.reject()

他的返回值就是一个已经失败的promise的实例

let pp=Promise.reject(100);
let pp=new Promise((res,rej)=>{
    rej(100);
})
//两者相等