Promise

1. 什么是Promise

Promise 是处理异步回调的解决方案，Promise 对象是一个容器,里面包裹了一个(些)异步操作,它表示一个预计会在未来完成的异步操作
其实是一个构造函数，自己身上有all、race、reject、resolve这几个方法，原型上有then、catch等方法

Promise对象有一下两个特点

1. Promise对象代表一个异步操作，有三种状态：pending（进行中）、fulfilled（已成功）和rejected（已失败）。只有进行异步操作的结果，可以决定当前是哪一种状态，任何其他操作都无法改变这个状态。
2. 状态一旦发生改变就会凝固，会一直保持这个状态，不会在发生变化，Promise状态的改变，只有两种可能：pending => fulfilled pending => rejected 。只要这两种情况发生，状态就凝固了，不会再变了，会一直保持这个结果。状态一旦改变就会触发Promise的then方法，then方法中有两个默认回调函数：resolve（成功后的回调）reject（失败后的回调）

Promise对象一旦创建成功就会立即执行(在 new Promise(同步))

	let p1 = new Promise((resolve, reject) => {
            resolve();//成功后的回调函数
            // reject();//失败后的回调函数
            console.log(1)
        })
         p1.then(//异步
             resolve => {
                console.log(2)
                console.log("成功后的回调")
            },
            reject => {
                console.log("失败后的回调")
            }
         )
         console.log(3)
         console.log(p1)

Promise当中有四个方法

reslove(成功后回调) reject(失败后回调) catch(错误的捕获) finally(都执行)

reslove reject 使用

在执行Promise时 如果成功就走then方法中的reslove结果，如果失败就走then方法中的reject结果。

		let p1 = new Promise((resolve, reject) => {
             resolve();//成功后的回调函数
             // reject();//失败后的回调函数
            console.log(1)
        })
         p1.then(//异步
             resolve => {
                console.log("成功后的回调")
            },
            reject => {
                console.log("失败后的回调")
            }
         )

catch方法的使用

在创建/使用promise的时候,如果代码报错,那么会自动的走then.reject回调函数,如果在then中没有写reject回调,会在catch中进行错误捕获,catch也可以捕获then方法中的报错

	  let p1 = function (num) {
             return new Promise((resolve, reject) => {
                 if (num >= 1) {
                     resolve(num);//成功后的回调函数
                 } else {
                     reject(num);//失败后的回调函数
                 }
             })
         }
         //catch也可以捕获then方法中的报错
         p1.then(//异步
             resolve => {
                 throw new Error("手动报错")
                 console.log("成功后的回调",resolve)
             },
             reject => {
                 console.log("失败后的回调",reject)
             }
         ).catch(
             err=>{
                 console.log("catch==>",err)
            }
         )

finally方法的使用

finally=>无论promise执行成功或者失败,也无所谓catch方法是否执行,finally方法都会执行

	let p1 = function (num) {
            return new Promise((resolve, reject) => {
                if (num >= 1) {
                    resolve(num);//成功后的回调函数
                } else {
                    reject(num);//失败后的回调函数
                }
            })
        }
        p1(1).then(//异步
            resolve => {
                // throw new Error("手动报错")
                console.log("成功后的回调",resolve)
            },
            reject => {
                console.log("失败后的回调",reject)
            }
        ).catch(
            err=>{
                console.log("catch==>",err)
            }
        ).finally(
            (fin)=>{
                console.log("finally===>",fin)
            }
        )

Promise对象API

Promise.all()

Promise.all() 如果都成功就正常返回,如果有一个失败,那么都会认为是失败的。里面的promise实例都是并行的,需要等到所有的promise都完成之后才会有结果

	let p1 = new Promise((resolve, reject)=>{
            setTimeout(()=>{
                resolve("p1");
            },1000)
        })
        let p2 = new Promise((resolve, reject)=>{
            setTimeout(()=>{
                resolve("p2");
            },3000)
        })
        let p3 = new Promise((resolve, reject)=>{
            setTimeout(()=>{
                // resolve("p3");
                reject("p3");
            },1000)
        })
        let pAll = Promise.all([p1,p2,p3]);
        pAll.then((res)=>{
            console.log(res)
        },err=>{
            console.log("err==>",err)
        });
        console.log(pAll);
        //当p1p2p3都执行完成后,pAll的状态变成已成功, 返回结果是参数的顺序
        //当p1p2p3中有任意一个失败,pAll会直接返回rejected, pAll的状态都是失败

Promise.race()

Promise.race() 返回的也是一个promise对象, race方法谁先有结果,就返回谁,无论成功还是失败(成功就走resolve,失败的会在reject中返回)
race 意思 赛跑 字面意思就是谁先有结果就返回谁

	let p1 = new Promise((resolve, reject)=>{
            setTimeout(()=>{
                // resolve("p1");
                reject("p1");
            },1000)
        })
        let p2 = new Promise((resolve, reject)=>{
            setTimeout(()=>{
                resolve("p2");
            },3000)
        })
        let p3 = new Promise((resolve, reject)=>{
            setTimeout(()=>{
                resolve("p3");
                // reject("p3");
            },2000)
        })
        let pRace = Promise.race([p1,p2,p3]);
        pRace.then((res)=>{
            console.log(res)
        },err=>{
            console.log("err==>",err)
        });
        console.log(pRace)

还有一个注意点

	 let p1 = Promise.resolve("let p1 = Promise.resolve");

		两者相同  p1 = p2     p2可以缩写成p1 格式

	 let p2 = new Promise((resolve, reject)=>{
            resolve("let p1 = Promise.resolve");
        })