Promise

promise 是什么？

        promise 是异步编程的一种解决方案指定回调函数方式更灵活易懂解决异步回调地狱的问题

什么是回调地狱？

        当一个回调函数嵌套一个回调函数的时候就会出现一个嵌套结构当前套的多了就会出现回调地狱的问题

Promise 对象共有3种状态：

        1. Pending ：进行中

        2. Resolved ：又称 Fulfilled ，已完成

        3. Rejected ：已失败

示例：

 resolves 成功
 reject 失败

var MyPromise = new Promise((resolve,reject)=>{
    var User = "Admin"
    if(User){
        return resolve("Admin")
    }else{
        return reject("error")
    }
})

.then 成功时调用
.catch 失败时调用

res跟err就是成功或者失败返回的值
像上面 成功 输出 Admin 失败 输出 error
像上面的if判断 就调用 .then 输出 Admin

MyPromise.then(res=>{
      console.log(res) 
  }).catch(err=>{
     console.log(err)
  })

Promise中提供了一个resolve方法来快速创建Promise对象，resolve方法中可以接受参数，如果传入的参数为 非Promise类型的对象, 则返回的结果为成功promise对象。如果传入的参数为 Promise 对象, 则参数的结果决定了 resolve 的结果。

reject方法和Promise.resolve()方法相似，区别在于无论reject方法中传递的是什么参数，PromiseState的状态都是rejected。

Promise.all()

all方法中要求我们传入包含 n 个 promise 的数组，结果返回一个新的 promise, 只有所有的 promise 都成功才成功, 只要有一个失败了就直接失败

var one = new Promise((resolve,reject)=>{

      one 案例一 return resolve("one:success")

      one 案例二 return reject("error")

     })
var two = new Promise((resolve,reject)=>{

        two 案例一 return resolve("two:success")

     })

Promise.all([one,two]).then(res=>{
       console.log(res)
  }).catch(err=>{
       console.log(err)
  })

运行 one 和 two 案例一则返回数组 Array [ "one:success", "two:success" ]

运行 one 案例二 和 two 案例一 则返回 error

Promise.race()

race方法是一个很有意思的方法，race的翻译是赛跑，它在这里的功能也和赛跑有些类似，传入多个Promise对象，第一个完成的 promise 的结果状态就会是最终的结果状态。

var one = new Promise((resolve,reject)=>{
      
     return resolve("one:success")
    
    // return reject("one:error")

   })
var two = new Promise((resolve,reject)=>{

     return resolve("two:success")

    // return reject("two:error")

    })

Promise.race([one,two]).then(res=>{
      console.log(res)
   }).catch(err=>{
      console.log(err)
   })

返回 one:success
第一个完成的 promise 的结果状态就会是最终的结果状态。

Promise.any()

Promise.any()方法只要参数实例有一个变成fulfilled状态，包装实例就会变成fulfilled状态，如果所有参数实例都变成rejected状态,包装实例就会变成rejected状态

var one = new Promise((resolve,reject)=>{
       
        setTimeout(()=>{
                // return resolve("one:success")
                   return reject("one:error")
        },1000)

     
     })
var two = new Promise((resolve,reject)=>{
      setTimeout(()=>{
                   return resolve("two:success")
                // return reject("two:error")
        },2000)
    })

 Promise.any([one,two]).then(res=>{
       console.log(res)
    }).catch(err=>{
       console.log(" error ")
  })

返回 two:success
如果都是 reject 返回 error 

Promise.allSettled()

Promise.allSettled()方法返回一个promise，该promise在所有给定的promise已被解析或被拒绝后解析，并且每个对象都描述每个promise的结果。

 var one = new Promise((resolve,reject)=>{
           return resolve("one:success")
      //   return reject("one:error")

        })
var two = new Promise((resolve,reject)=>{
      // return resolve("two:success")
         return reject("two:error")
    })

Promise.allSettled([one,two]).then(res=>{
            console.log(res)
     }).catch(err=>{
            console.log(err)
    })
    不管是 resolve 还是 reject 都会走.then里面 

    如果一个返回 resolve  一个返回 reject 
    返回 Array [ 
​
                0: Object { status: "fulfilled", value: "one:success" }
​    
                1: Object { status: "rejected", reason: "two:error" }
          ]
    都是返回 reject 则 status 状态都是 rejected

​

中断promise调用链

当使用 promise 的 then 链式调用时, 假如说我们想要中断promise的调用链，我们可以在回调函数中返回一个 pendding 状态的 promise 对象，不再调用后面的回调函数。