ES6中的Promise

1.Promise的含义

Promise 是异步编程的一种解决方案。所谓Promise，简单说就是一个容器，里面保存着某个未来才会结束的事件（通常是一个异步操作）的结果。

Promise对象的特点：

（1）promise对象的状态不受外界影响。Promise对象代表一个异步操作，它有三种状态：pending（等待状态）处于未决阶段、fulfilled（resolved 已成功）处于已决阶段、rejected（已失败）处于已决阶段。只有异步操作的结果，可以决定当前时哪一种状态，任何其他操作都无法改变这个状态。

（2）一旦改变状态，就不会再变，任何时候都可以得到这个结果。Promise对象的状态改变，只有两种可能：从pending变为fulfilled（resolved）和从pending变为rejected。只要这两种情况发生，状态就凝固了，不会再发生改变，并且一直保持这个结果。

2.基本用法

Promise对象是一个构造函数，用来生成Promise实例。

const promise = new Promise(function(resolve, reject) {

  if (/* 异步操作成功 */){

    resolve(value);

  } else {

    reject(error);

  }

});

resolve函数的作用是，将Promise对象的状态从 pending 变为 resolved，在异步操作成功时调用，并将异步操作的结果，作为参数传递出去；reject函数的作用是，将Promise对象的状态从 pending 变为 rejected，在异步操作失败时调用，并将异步操作报出的错误，作为参数传递出去。

Promise实例生成以后，可以用then方法分别指定resolved状态和rejected状态的回调函数。

promise.then(function(value) {

  // success

}, function(error) {

  // failure

});

举个例子：

const pro = new Promise((resolve,reject)=>{
      console.log("xx同学发送晚餐请求")
      setTimeout(()=>{
          if(Math.random() > 0.5){
                 // 一半的同学收到了信息
                 if(Math.random() < 0.3){
                      resolve(true)
                  }else{
                      resolve(false)
                  }
             }else{
                  // 一半没有收到信息
                  reject("没有收到晚餐邀请")
             }
         },1000)
  })
  pro.then(data=>{
       console.log(data)
  },err=>{
       console.log(err)
  })

then方法可以接受两个回调函数作为参数。第一个回调函数是Promise对象的状态变为resolved时调用，第二个回调函数是Promise对象的状态变为rejected时调用。这两个函数都是可选的，不一定要提供。它们都接受Promise对象传出的值作为参数。

注意：只有当抛出异常（例如使用throw 抛出异常）Promise对象的状态会变为rejected时，then方法的err函数才会执行。

3.注意点

（1）未决阶段的处理函数是同步代码，会立即执行

let promise = new Promise(function(resolve, reject) {
  console.log('Promise');
  resolve();
});

promise.then(function() {
  console.log('resolved.');
});

console.log('Hi!');

// Promise
// Hi!
// resolved

（2）then方法中的两个回调函数（resolved和rejected函数的后续处理函数）是异步函数，就算是立即执行，也会加入到任务队列的微队列中。

（3）then方法有两个参数，分别是Promise对象是resolved和rejected状态的后续处理函数，但是catch方法只有一个参数，它只能单独添加Promise对象是rejected状态的后续处理函数。

        console.log(4)
        const pro = new Promise((resolve,reject)=>{
            console.log(1)
            // resolve(2)//微队列
            reject(1111111)
            setTimeout(()=>{//宏队列
                console.log(3)
            },0)
        })
        pro.then((data)=>{
            console.log(data)
        },(err)=>{
            console.log(err)
        })
        pro.catch((err)=>{
            console.log(err)
        })
        console.log(5)


//4
//1
//5
//111111
//111111
//3

（4）在未决阶段的处理函数中，如果发生未捕获的错误，会将状态推向rejected状态，并且会被catchable捕获。

（5）一旦状态推向已决阶段，无法做出任何改变。

        const pro = new Promise((resolve,reject)=>{
            try {
                throw new Error("123456789") //未捕获的错误
            } catch (error) {
                console.log(error)
            }
            resolve(1)//无效
        })
        pro.then(data=>{
            console.log(data)
        },err=>{
            console.log(err,"错误")
        })

（6）如果前面的promise的后续处理，返回的是一个promise，则返回的promise状态和后续处理返回的promise状态保持一致。

        const pro1 = new Promise((resolve,reject)=>{
            // resolve(1)
            reject(2)
        }) 
        const pro2 = new Promise((resolve,reject)=>{
            // resolve(2)
            reject(2)
        })

        let a = pro1.then(data=>{
            console.log(data)
            return pro2;
            // return 1111
        },err=>{
            console.log(err)
            // return 2222;
            throw new Error("2222")
        })

以上代码中的变量a的返回值会根据pro1的状态发生改变。（保持一致）。