ECMAscript 6 中 Promise的原理以及使用

promise
ECMAscript 6 原生提供了 Promise 对象。
promise 对象用于表示一个异步操作的最终完成 (或失败)及其结果值。
promsie必然处于以下几种状态之一：

• 待定（pending）: 初始状态，既没有被兑现，也没有被拒绝。

• 已兑现（fulfilled）: 意味着操作成功完成。

• 已拒绝（rejected）: 意味着操作失败。

  待定状态的 Promise 对象要么会通过一个值被兑现（fulfilled），要么会通过一个原因（错误）被拒绝（rejected）。当这些情况之一发生时，我们用 promise 的 then 方法排列起来的相关处理程序就会被调用。如果 promise 在一个相应的处理程序被绑定时就已经被兑现或被拒绝了，那么这个处理程序就会被调用，因此在完成异步操作和绑定处理方法之间不会存在竞争状态。
  

promise的优缺点：
优点：
有了 Promise 对象，就可以将异步操作以同步操作的流程表达出来，避免了层层嵌套的回调函数。
Promise 对象提供统一的接口，使得控制异步操作更加容易。
缺点：
无法取消 Promise，一旦新建它就会立即执行，无法中途取消。
如果不设置回调函数，Promise 内部抛出的错误，不会反应到外部。
当处于 Pending 状态时，无法得知目前进展到哪一个阶段（刚刚开始还是即将完成）
promise创建：
使用new来调用promise的构造器创建实例

var promsie =new Promise(function(resolve,reject){
    //异步处理
    // 处理结束后调用resolve或者reject
})

Promise 构造函数包含一个参数和一个带有 resolve（解析）和 reject（拒绝）两个参数的回调。在回调中执行一些操作（例如异步），如果一切都正常，则调用 resolve，否则调用 reject。
因为 Promise.prototype.then 和 Promise.prototype.catch 方法返回的是 promise， 所以它们可以被链式调用。
promise的链式调用：
promise.prototype.then()
Promise.prototype.then 方法返回的是一个新的 Promise 对象，因此可以采用链式写法。
then()两个回调函数都可以接受参数，参数值是为对应的resolve()和reject()传递的参数值

var myFirstPromise = new Promise(function(resolve, reject){
    //当异步代码执行成功时，我们才会调用resolve(...), 当异步代码失败时就会调用reject(...)
    setTimeout(function(){
        resolve("成功!"); //代码正常执行！
        reject('失败')
    }, 250);
}).then(function(successMessage){
    //successMessage的值是上面调用resolve(...)方法传入的值.
    //successMessage参数不一定非要是字符串类型，这里只是举个例子
    console.log(successMessage,'嘻嘻')
}).catch(function(rejectMessage){
    console.log(rejectMessage,'ei')
});

Promise.prototype.catch()捕捉错误
Promise.prototype.catch 方法是 Promise.prototype.then(null, rejection) 的别名，用于指定发生错误时的回调函数。
Promise 对象的错误具有"冒泡"性质，会一直向后传递，直到被捕获为止。也就是说，错误总是会被下一个 catch 语句捕获。

let testPromise = new Promise(function (resolve, reject) {
    var a = 5
    if (a === 6) {
      resolve('success')
    } else {
      reject('catch error')
    }
  }).then(function(successMessage){
    console.log(successMessage)
  }
  ).catch(err => {
    console.log('catch error')
    console.log(err)
  })

Promise.prototype.finally()
finally() 方法返回一个Promise。在promise结束时，无论结果是fulfilled或者是rejected，都会执行指定的回调函数。这为在Promise是否成功完成后都需要执行的代码提供了一种方式。
这避免了同样的语句需要在then()和catch()中各写一次的情况。

let testPromise = new Promise(function (resolve, reject) {
    var a = 5
    if (a === 5) {
      resolve('success')
    } else {
      reject('catch error')
    }
  }).then(function(successMessage){
    console.log(successMessage)
  }
  ).catch(err => {
    console.log('catch error')
    console.log(err)
  }).finally(()=>{console.log("都要执行哟")})

静态方法：
先new三个promise对象 作为实验对象

 var p1=new Promise((resolve,reject)=>{
      let x=1
       if(x == 1 ){
           resolve("a成功拉")
       }
  })
  var p2=new Promise((resolve,reject)=>{
    let x=1
     if(x == 2 ){
        resolve("b成功拉")
     }else{
         reject("b失败了")
     }
})
var p3=new Promise((resolve,reject)=>{
    let x=1
     if(x ==1 ){
         resolve("c成功拉")
     }
})

Promise.all()
Promise.all可以将多个Promise实例包装成一个新的Promise实例。同时，成功和失败的返回值是不同的，成功的时候返回的是一个结果数组，而失败的时候则返回最先被reject失败状态的值。

Promise.all([p1,p3]).then((result)=>{
    console.log(result)
}).catch((error)=>{
    console.log(error)
})
Promise.all([p1,p2,p3]).then((result)=>{
    console.log(result)
}).catch((error)=>{
    console.log(error)
})

Promise.race()
Promse.race就是赛跑的意思，意思就是说，Promise.race([p1, p2, p3])里面哪个结果获得的快，就返回那个结果，不管结果本身是成功状态还是失败状态。

Promise.race([p1,p2,p3]).then((result)=>{
    console.log(result)
}).catch((error)=>{
    console.log(error)
})

Promise.allSettled()
等到所有promises都已敲定（settled）（每个promise都已兑现（fulfilled）或已拒绝（rejected））。
返回一个promise，该promise在所有promise完成后完成。并带有一个对象数组，每个对象对应每个promise的结果。

Promise.allSettled([p1,p2,p3]).then((result)=>{
    console.log(result)
}).catch((error)=>{
    console.log(error)
})