ES6中Promise的基本用法

一、Promise的含义

Promise 是异步编程的一种解决方案，比传统的解决方案——回调函数和事件——更合理和更强大。它由社区最早提出和实现，ES6 将其写进了语言标准，统一了用法，原生提供了Promise对象。

所谓Promise，简单说就是一个容器，里面保存着某个未来才会结束的事件（通常是一个异步操作）的结果。从语法上说，Promise 是一个对象，从它可以获取异步操作的消息。Promise 提供统一的 API，各种异步操作都可以用同样的方法进行处理。

有了Promise对象，就可以将异步操作以同步操作的流程表达出来，避免了层层嵌套的回调函数。此外，Promise对象提供统一的接口，使得控制异步操作更加容易。

二、Promise的使用方法

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

ES6将一件事情可以发生异步操作的时候，分为两个阶段unsettled未决阶段和settled已决阶段

ES6将程序分为三种状态：pending（进行中）、fulfilled（已成功）和rejected（已失败）。

Promise构造函数接受一个函数作为参数，该函数的两个参数分别是resolve和reject。它们是两个函数，由 JavaScript 引擎提供，不用自己部署

const pro = new Promise(function (resolve, reject) {
   if ((Math.random() * 10 | 0) > 5 ) {
       resolve('1');
   } else {
       reject('2');
   }
});

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

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

 pro.then(data=>{
    console.log("完成",data)
},err=>{
    console.log("失败",err)
})

resolve和reject函数只可以使用一个，如果使用多个，也只有第一个有用，参数只能有一个

const pro = new Promise(function (resolve, reject) {
        resolve('1');
        reject('2');
        resolve('3');
});
pro.then(data=>{
    console.log("完成",data)
},err=>{
    console.log("失败",err)
})

方法的使用

then()方法

它的作用是为 Promise 实例添加状态改变时的回调函数。前面说过，then方法的第一个参数是resolved状态的回调函数，第二个参数（可选）是rejected状态的回调函数。

then方法返回的是一个新的Promise实例（注意，不是原来那个Promise实例）。因此可以采用链式写法，即then方法后面再调用另一个then方法。

const pro = new Promise(function (resolve, reject) {
        if ((Math.random() * 10 | 0) > 5 ) {
		       resolve('1');
		   } else {
		       reject('2');
		   }
});
//可设置两种状态的回调函数
pro.then(data=>{
   console.log("完成",data)
},err=>{
    console.log("失败",err)
})
//也可设置一种状态状态的回调函数，但只能是resolved状态的
pro.then(data=>{
    console.log("完成",data)
}))

catch()方法
它方法是**.then(null, rejection)**的别名，用于指定发生错误时的回调函数。

const pro = new Promise(function (resolve, reject) {
 	reject('2');
});
//两种写法效果一样
pro.then(null,err=>{
    console.log("失败",err)
})

pro.catch(err=>{
    console.log("失败",err)
})

all()方法
用于将多个 Promise 实例，包装成一个新的 Promise 实例。如果里面所有的promise对象都成功才会触发，一旦有一个失败

const arr = []
for (let i = 0; i < 10; i++) {
   arr.push(new Promise(function (resolve, reject) {
        if ((Math.random() * 10 | 0) < 9) {
            console.log(i,"完成")
            resolve(i)
            }else{
            console.log(i,"失败")
            reject(i);
        }
    }))
}
const pro = Promise.all(arr)
pro.then(data => {
    console.log("完成", data)
}, err => {
    console.log("失败", err)
})

finally()方法
用来测试promise是否已到已决状态，不管promise最后的状态，在执行完then或catch指定的回调函数以后，都会执行finally方法指定的回调函数。

const pro = new Promise(function (resolve, reject) {
    if ((Math.random() * 10 | 0) > 5) {
        resolve('1');
    } else {
        reject('2');
    }

});
pro.then(data => {
    console.log("完成", data)
}, err => {
    console.log("失败", err)
})
pro.finally(() => {
    console.log('已到达')
})

race()方法
当多个promise对象先改变状态，p的状态就跟着改变。那个率先改变的 Promise 实例的返回值，就传递给p的回调函数。不论这个结果是成功还是失败

 const arr = []
 for (let i = 0; i < 10; i++) {
     arr.push(new Promise(function (resolve, reject) {
         setTimeout(() => {
             if ((Math.random() * 10 | 0) < 9) {
                 console.log(i, "完成")
                 resolve(i)
             } else {
                 console.log(i, "失败")
                 reject(i);
             }
         },(Math.random()* (3000-1000) + 1000 | 0))
     }))
 }
 const pro = Promise.race(arr)
 pro.then(data => {
     console.log("完成", data)
 }, err => {
     console.log("失败", err)
 })