1.Promise是什么？

1.Promise是异步编程的一种解决方案，在ES6中Promise被列为了正式规范，统一了用法，原生提供了Promise对象。

2.Promise的基础用法

// resolve代表成功 reject失败 都是一个函数

let p = new Promise(function(reslove,reject){

    //reslove('成功')  //状态由等待变为成功，传的参数作为then函数中成功函数的实参

    reject('失败')  //状态由等待变为失败，传的参数作为then函数中失败函数的实参

})

//then中有2个参数，第一个参数是状态变为成功后应该执行的回调函数，第二个参数是状态变为失败后应该执行的回调函数。

p.then((data)=>{

    console.log('成功'+data)

},(err)=>{

    console.log('失败'+err)

})

Promise(承诺) 表示未来的某个时间一定会返回一个结果

Promise 是一个容器,里面包裹了一些异步操作,它表示一个预计会在未来完成的异步操作

PromiseState(promise状态) pending(进行中) fulfilled(已成功) rejected(已失败)

    Promise状态变化pending =>fulfilled 或者 pending=>rejected 不可逆的,而且一旦执行成功状态就会凝固 不会在发生其他变化了

    Promise实例上 有三个api

     then(resolve=>{},reject=>{}) 方法中有两个回调函数 分别表示成功后的回调 和失败后的回调

     catch(err=>{}) 在创建或者使用promise的时候,如果代码报错那么会自动的走then.reject 如果在then中没有reject回调,会在catch中进行错误捕获, catch方法也会捕获在then方法中发生任何错误

     finally(()=>{})  无论promise执行成功或者失败,也无论catch方法是否执行, 最终finally都会执行

 // Promise的API 应用程序接口
    //Promise.resolve
    //Promise.reject
    //Promise.all 全部 Promise.all方法 参数是多个promise对象组成的数组, 返回值是一个新的promise对象
        //如果参数中的promise对象都成功就正常返回,并且promiseAll方法中的每一个promise都是并行状态,当全部完成之后就会自动的调用promise.all().then()方法.
        //如果参数中的promise对象有任意一个没有正常返回,那么整个pAll都会认为是失败的,并且把失败的这个promise对象的返回值直接输出 其他的就不会在继续执行了

    {
        let p1 = new Promise((resolve, reject) => {
            resolve(1)
        });
        p1.then((res) => {
            console.log(res);
        })

        let p2 = Promise.resolve(1)

        p2.then((res) => {
            console.log(res);
        })
    }
    {
        let p1 = new Promise((resolve, reject) => {
            reject(1)
        });
        p1.then((res) => {
            console.log(res);
        }).catch(err => {
            console.log("p1 catch", err);
        })

        let p2 = Promise.reject(1)

        p2.then((res) => {
            console.log(res);
        }).catch(err => {
            console.log("p2 catch", err);
        })
    }
    {//Promise.all 全部
        //Promise.all 如果都成功就正常返回, 有一个失败,那么都会认为是失败的
        //Promise.all里面的promise实例 都是并行的, 需要等到所有的promise实例都执行完后才会有结果
        //promise实例都执行完之后 pAll状态变为已成功, 返回结果是参数的顺序
        //当有任意一个失败 pAll会直接返回rejected, pAll的状态都是失败的
        /*let p1 = new Promise((resolve, reject) => {
            setTimeout(() => {//模拟异步
                resolve("p1")
            }, 1000)
        });
        let p2 = new Promise((resolve, reject) => {
            setTimeout(() => {//模拟异步
                resolve("p2")
            }, 5000)
        });
        let p3 = new Promise((resolve, reject) => {
            setTimeout(() => {//模拟异步
                reject("p3")
            }, 2000)
        });
        let pAll = Promise.all([p1, p2, p3]);
        pAll.then(
            resolve => {
                console.log("成功后的回调",resolve);//"成功后的回调",["p1", "p2", "p3"]
            },
            reject => {
                console.log("失败后的回调",reject);
            })*/

    }
    {//Promise.race
        //Promise.race方法返回的也是一个promise对象, race方法谁先有结果就返回谁,无论成功还是失败(成功的就走resolve,失败就会在reject中返回)
        let p1 = new Promise((resolve, reject) => {
            setTimeout(() => {//模拟异步
                reject("p1")
            }, 1000)
        });
        let p2 = new Promise((resolve, reject) => {
            setTimeout(() => {//模拟异步
                resolve("p2")
            }, 5000)
        });
        let p3 = new Promise((resolve, reject) => {
            setTimeout(() => {//模拟异步
                resolve("p3")
            }, 2000)
        });
        let pRace = Promise.race([p1, p2, p3]);
        pRace.then(
            resolve => {
                console.log("成功后的回调",resolve);//成功后的回调 p1
            },
            reject => {
                console.log("失败后的回调",reject);//失败后的回调 p1
            })

    }