1.Promise的含义

Promise是异步编程的一种解决方案。Promise是一个对象，从它可以获取异步操作的消息

Promise对象有以下两个特点

1.对象的状态不受外界影响。Promise对象代表一个异步操作，有三种状态：pending（进行中）、fulfilled（已成功）和rejected（已失败）。只有异步操作的结果，可以决定当前是哪一种状态，任何其他操作都无法改变都无法改变这个状态，这也是promise这个名字的由来，它的翻译是“承诺”，表示其他手段无法改变

2.一旦状态改变，就不会再变，任何时候都可以得到这个结果。Promise对象的状态改变，只有两种可能：从pending变为fulfilled和从pending变为rejected。只要这两种情况发生，状态就凝固了，不会再改变了，会一直保持这个结果，这时就称为resolved。如果改变已经发生了，你再对Promise对象添加回调函数，也会立即得到这个结果。这与事件完全不同，事件的特点是，如果你错过了它，再去监听，是得不到结果的

Promise也有一些缺点

首先，无法取消promise，一旦新建它就会立即执行，无法中途取消。其次，如果不设置回调函数，Promise内部抛出的错误，不会反映到外部，第三，当处于pending状态时，无法得知目前进展到哪一个阶段（刚刚开始还是即将完成）

2.基本用法

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

  const promise = new Promise(function (resolve, reject) {
      if (/* 异步操作成功 */) {
        resolve(value)
      } else {
        reject(error)
      }
    })

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

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

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

promise.then(function(value){
    //success
},function(err){
    //failure
})

3.Promise.prototype.then()

Promise实例具有then方法，也就是说，then方法是定义在原型对象Promise.prototype上的。它的作用是为promise实例添加状态改变时的回调函数

采用链式的then，可以指定一组按照次序调用的回调函数。这时，前一个回调函数，有可能返回的还是一个promise对象。这时候一个回调函数，就会等待该Promise对象的状态发生变化，才会被调用

const p1 = PromiseA.reject(500).then((value)=>{
      console.log(value,'成功');
    },(err)=>{
      console.log('失败',err);
    })
    const f1 = new PromiseA((resolve, reject) => {
      setTimeout(() => {
        resolve('成功')
        // reject('失败11')
      }, 3000)
    })
    f1.then((value) => {
      console.log('成功', value);
      return new PromiseA((resolve, reject) => {
        resolve(9999)
      })
    }, (err) => {
      console.log('失败', err);
      return new PromiseA((resolve, reject) => {
        reject(99998)
      })
    }).then((value) => {
      console.log('成功2', value);
      return 222
    }, (err) => {
      console.log('失败2', err);
      return 666
    }).then((value) => {
      console.log('成功3');
    }, (err) => {
      console.log('失败3', err);
    })

4.Promise.prototype.catch()

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

getJSON('./1.json').then(function(poots){
}).catch(function(error){
//处理getJSON和前一个回调函数运行时发生的错误
console.log('发生错误',error)
});

在上面代码中，getJSON（）方法返回一个Promise对象，如果该对象状态变为resolved，则会调用then（）方法指定的回调函数；如果异步操作抛出错误，状态就会变为rejected，就会调用catch（）方法指定的回调函数，处理这个错误，另外，then（）方法指定的回调函数，如果在运行中抛出错误，也会被catch（）方法捕获

const promise = new Promise(function(resolve,reject){
    reject(new Error('test')
})
promise.catch(function(error){
    console.log(error)
})

如果Promise状态已经变成resolved，再抛出错误是无效的

5.Promise.prototype.finally()

finally()方法用于指定不管promise对象最后状态如何，都会执行的操作。

finally方法的回调函数不接受任何参数，这意味着没有办法知道，前面的promise状态到底是fulfilled还是rejected。这表明，finally方法里面的操作，应该是与状态无关的，不依赖于promise的执行过程 finally本质上是then方法的特例

promise.finally(() =>{
   //语句
})
//等同于
promise.then(result=>{
   //语句
},error=>{
   //语句
   throw error;
}}

上面diamante中，如果不使用finally方法，同样的语句需要为成功和失败两种情况各写一次，有了finally方法，只需要写一次

Promise.prototype.finally = function(callback){
let p = this.constructor;
return this.then(
    value =>p.resolve(callback()).then(()=>value),
    reason =>p.resolve(callback()).then(()=>{throw reason)
)

上面代码中，不管前面的promise是fulfilled还是rejected，都会执行回调函数callback

6.Promise.all()

Promise.all()方法用于将多个Promise实例，包装成一个新的Promise实例

const p = Promise.all([p1,p2,p3])

上面代码中，Promise.all()方法接收一个数组作为参数，p1,p2,p3都是Promise实例，如果不是，就会先调用下面讲到的Promise.resolve方法，将参数转为Promise实例，再进一步处理。另外，Promise.all（）方法的参数可以不是数组，但必须有Iterator接口，且返回的每个成员都是promise实例

分为两种两种情况

只有p1,p2,p3的状态都变成fulfilled，p的状态才会变成fulfilled，此时p1,p2,p3的返回值组成一个数组，传递给p的回调函数

只要p1,p2,p3之中有一个被rejected,p的状态就会变成rejected，此时第一个被reject的实例的返回值，会传递给p的回调函数

const promise = [1,2,3,4].map(function(id){
    return getJSON('/post/'+id+".json")
})
Promise.all(promises).then(funtion(poots){
    //
}).catch(function(reason){
    //
})

上面代码中，promise是包含6个Promise实例的数组，只有这6个实例的状态都变成fulfilled，或者其中有一个变为rejected，才会调用Promise.all方法后面的回调函数

7.Promise.race()

Promise.race()方法同样是将多个Promise实例，包装成一个新的Promise实例

const p = Promise.race([p1,p2,p3])

上面代码中，只要p1,p2,p3之中有一个实例率先改变状态，p的状态就跟着改变，那个率先改变的promise实例的返回值，就传递给p的回调函数

8.Promise.allSettled()

Promise.all()方法只适合所有异步操作都成功的情况，如果有一个操作失败，就无法满足要求

const = urls = [url1,url2,url3];
const requsts = url.map(x =>fetch(x))
try{
await Promise.all(requests)
console.log('所有请求都成功')
}catch{
 console.log('至少一个请求失败，其他请求可能还没结束')
}

上面示例中，Promise.all()可以确定所有请求都成功了，但是只要有一个请求失败，它就会报错，而不管另外的请求是否结束

下章正在制作中，喜欢点个关注叭

详解Promise对象·上