promise解析

定义：

就是一个容器，里面保存着某个未来才会结束的事件（通常是一个异步操作）的结果

特点：

1）对象的状态不受外界的影响，Promise对象代表一个异步操作，有三种状态：pending（进行中)、fulfilled（已成功）、rejected（已失败）
2）一旦状态改变，就不会再变，任何时候都可以得到结果。

缺点：

1）：一旦新建它就会立即执行，无法中途取消，
2）如果不设置回调函数，promise 内部，抛出的错误，不会反应到外部，
3）当处于pending状态时，无法得知目前进展到哪一个阶段

promise 的状态结果：

一共有两种：

• pending（初始化） 到 成功 及 fulfilled
• pending（初始化） 到 失败及reject

状态一旦改变之后 就不可以再 变化了

  let p =   new Promise(function (resolve, reject) {
            //resolve 成功
            //reject 失败
            $.ajax({
                    url:'请求的接口',
                    success:function(res){
                    // http状态码是200
                       resolve(res)
                    },
                    error:function(err){
                        // http状态码是其他
                        reject(err)
                    }
                }) 
        })

axios 就是基于promise原理实现的

作用：

promise 可以解决复杂的异步依赖 （异步套异步） 去解决地狱回调，死亡循环

setTimeout(function () {
                    setTimeout(function () {
                        setTimeout(function () {
        
                        }, 1000)
                    }, 1000)
                }, 1000)

大量的异步嵌套 代码结构复杂混乱 不利于后期修改

解决地狱回调问题

 function timer(count) {
        var p = new Promise((resolve, reject) => {
            setTimeout(() => {
                //console.log(1)
                //resolve(count)
                reject(count)
            }, 1000)
        })
        return p
    }
    timer('1')
        .then((res)=>{
            console.log(res)
            return timer('2')
        })
        .then((res)=>{
            console.log(res)
            return timer('3')
        })
        .then((res)=>{
            console.log(res)
            return timer('4')
        })
        .then((res)=>{
            console.log(res)
        })
        .catch((err)=>{
            console.log(err)
        })

promiseAPI

Promise.all()

• Promise.all() 可以把多个promise实例 整合成一个新的promise实例 这里面也会调取成功和失败 但是有一点不同
  成功的时候数据会以数组的形式出现 失败的时候 不管是否成功 都直接输出失败
• 成功的时候 数据以数组形式出现 例：[“成功咯”, “又成功咯”] 实例位置变化 会导致输出结果的变化

     let p1 = new Promise((resolve,reject)=>{
            resolve('成功咯')
        })
        let p2 = new  Promise((resolve,reject)=>{
            resolve('又成功咯')
        })
        let p3 = Promise.reject('很遗憾，挂了') 

        Promise.all([p1,p2])
        .then((res)=>{
            console.log(res,'res')  //成功的时候  数据以数组形式出现["成功咯", "又成功咯"] 实例位置变化 会导致输出结果的变化
        })
        .catch((err)=>{
            console.log(err,'err')
        }) 

        Promise.all([p1,p3,p2])
        .then((res)=>{
            console.log(res,'res带失败的')
        })
        .catch((err)=>{
            console.log(err,'err失败的') //有失败的情况 直接走失败的内容 不会输出任何成功信息
        }) 

Promise.race()

• Promise.race() 赛跑的意思 顾名思义 谁先执行完 谁就先输出 与位置无关
• 它这个方法 不管成功还是失败 都可以输出来 然后 输出的顺序 按照 谁先执行完 谁先输出来

    function timer(msg,count){
        let p = new Promise((resolve,reject)=>{
            setTimeout(()=>{
                resolve({code:200,msg})
            },count)
         })
        return p
     }
     let p4 = timer('我是p4',6000).then((res)=>{
         console.log(res)
    })
    let p5 = timer('我是p5',5000).then((res)=>{
        console.log(res)
     })
     Promise.race([p5,p4]) 

它这个方法 不管成功还是失败 都可以输出来 然后 输出的顺序 按照 谁先执行完 谁先输出来