我们知道的，在 JavaScript 中，所有代码都是单线程的，也就是同步执行的。而 Promise 就为异步编程提供了一种解决方案。

1 基本概念

---

• 名称：
  译为“承诺”，这也就表达了将来会执行的操作，代表异步操作；
• 状态：
  一共有三种状态，分别为pending（进行中）、fulfilled（已成功）和rejected（已失败）。
• 特点：
  (1)只有异步操作可以决定当前处于的状态，并且任何其他操作无法改变这个状态；
  (2)一旦状态改变，就不会在变。状态改变的过程只可能是：从pending变为fulfilled和从pending变为rejected。如果状态发生上述变化后，此时状态就不会在改变了，这时就称为resolved（已定型）

2 基本用法

---

Promise 对象是由关键字 new 及其构造函数来创建的。
首先，
介绍一下如何创建一个 Promise；

const promise = new Promise((resolve, reject) => {
    // do something here ...
    if (success) {
        resolve(value); // fulfilled
    } else {
        reject(error); // rejected
    }
});

由上述代码我们可知：
该构造函数接收两个函数作为参数，分别是resolve和reject。
当异步操作执行成功后，会将异步操作结果作为参数传入resolve函数并执行，此时 Promise对象状态从pending变为fulfilled；
失败则会将异步操作的错误作为参数传入reject函数并执行，此时 Promise对象状态从pending变为rejected；

接下来，
我们通过then方法，分别指定resolved状态和rejected状态的回调函数。

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

then方法可以接收两个回调函数作为参数，第一个回调函数就是fulfilled状态时调用；第二个回调函数就是rejected时调用。这边的第二个参数是可选的，不一定要提供。

3 方法

---

(1) Promise.all(iterable)

• 参数
  iterable 必须是一个可迭代对象，如 Array 或 String。
• 返回值
  一个新的Promise实例。

Promise.all 的使用
如果传入的参数中存在不是Promise实例，则会先调用Promise.resolve，将其转为Promise实例，再进一步处理。

var p1 = Promise.resolve(3);
var p2 = 1337;
var p3 = new Promise((resolve, reject) => {
  setTimeout(resolve, 100, 'foo');
}); 

Promise.all([p1, p2, p3]).then(values => { 
  console.log(values); 
});

//  [3, 1337, "foo"] 

Promise.all 的异步和同步
如果传入的参数为空的可迭代对象，则同步返回一个已完成（already resolved）状态的 Promise；
非空时则返回一个异步完成（asynchronously resolved） Promise

var iterable = [Promise.resolve(1), Promise.resolve(2)];

var p = Promise.all(iterable);

console.log(p);

setTimeout(function(){
    console.log(p);
});

// Promise {<pending>}
// Promise {<resolved>: Array(2)}

Promise.all 的快速返回失败行为
传入的参数中任意一个promise返回失败时，那么整体立即返回失败，返回的错误信息是第一个失败的promise结果。

var p1 = new Promise((resolve, reject) => { 
  setTimeout(resolve, 1000, 'one'); 
}); 
var p2 = new Promise((resolve, reject) => { 
  setTimeout(resolve, 2000, 'two'); 
});
var p3 = new Promise((resolve, reject) => {
  setTimeout(resolve, 3000, 'three');
});
var p4 = new Promise((resolve, reject) => {
  reject('p4 reject!');
});
var p5 = new Promise((resolve, reject) => {
  reject('p5 reject!');
});

Promise.all([p1, p2, p3, p4, p5]).then(values => { 
  console.log(values);
}, reason => {
  console.log(reason)
});

// p4 reject!

.
.
.
.
.
.

(2) Promise. race(iterable)

• 参数
  iterable 必须是一个可迭代对象，如 Array 或 String。
• 返回值
  一个新的Promise实例。

Promise.race 的使用
race有赛跑之译，因此返回的新实例状态，是跟随参数中最先改变状态的那个实例；如果不是Promise实例，依旧先用Promise.resolve方法，转化后再进一步处理。
如果传的迭代为空，则返回的 Promise 永远等待

var promise1 = new Promise(function(resolve, reject) {
    setTimeout(resolve, 500, 'one-resolve-500');
});

var promise2 = new Promise(function(resolve, reject) {
    setTimeout(reject, 400, 'two-reject-400');
});

Promise.race([promise1, promise2]).then(function(value) {
    console.log(value);
}, function(err) {
    console.log(err);
});

// two-reject-400

.
.
.
.
.
.

(3) Promise.resolve(value)

返回一个以给定的值解析后的Promise对象；
参数 value 主要有以下几种情况：

• 一个Promise实例
  原封不动的返回该实例；

  var original = Promise.resolve('我在第二行');
  var cast = Promise.resolve(original);
  cast.then(function(value) {
    console.log('value: ' + value);
  });
  console.log('original === cast ? ' + (original === cast));
  
  // "original === cast ? true"
  // "value: 我在第二行"
  

• 一个thenable对象：是指含有then方法的对象
  跟随这个thenable对象的，采用它的最终状态；

  let thenable = {
    then: function(resolve, reject) {
      resolve(42);
    }
  }
  
  let p = Promise.resolve(thenable);
  
  p.then(function(value) {
    console.log(value);
  })
  
   // 42
  

• 普通数据：[String|Array|Object|Number]
  直接将传入参数当最终结果并返回一个新的Promise；

  let p = Promsie.resolve(123);
  p.then(function(num) {
    console.log(num);
  })
  
  // 123
  

• 无参数
  直接返回一个resolved状态的Promise对象

  let p = Promsie.resovle();
  p.then(function() {
    // do something here...
  })
  

.
.
.
.
.
.

(4) Promise.reject(reason)

• 参数：表示被拒绝的原因；

⚠️传入的参数会原封不动的作为 reject 函数的理由，并不会因为传入的参数 Promise 或者是 thenable 对象而有所不同

• 返回值：一个含有reason的状态为rejected的Promise

.
.
.
.
.
.

4 Promise原型

---

(1) Promise.prototype.then()

Promise 的实例具有 then 方法，主要作用是为 Promise 实例发生状态改变时添加回调函数。
它接收两个回调函数作为参数，第一个参数是 fulfilled状态时的回调函数；第二个参数是rejected状态时的回调函数，可不传入。
并且该方法返回一个新的Promise对象。

• 语法：

  p.then(onResolve, onReject);
  
  p.then(function(value) {
     // fulfillment
    }, function(reason) {
    // rejection
  });
  

.
.
.
.

(2) Promise.prototype. catch()

返回一个Promise，并且处理拒绝的情况。它的行为与调用Promise.prototype.then(undefined, onRejected)相同。

• 语法

  p.catch(onReject)
  
   p.catch(function(reason) {
       // 拒绝
   });
  

• 推荐使用catch方法，不要在then方法中定义rejected状态的回调函数；这是因为使用catch还可以捕获在then方法执行中存在的错误。

    // bad
  promise
    .then(function(data) {
      // success
    }, function(err) {
      // error
    });
  
  // good
  promise
    .then(function(data) { 
      // success
    })
    .catch(function(err) {
      // error
    });
  

.
.
.
.
.
.

(3) Promise.prototype. finally()

返回一个Promsie。是指，在上一轮 promise 运行结束后，无论fulfilled还是 rejected，都会执行指定的回调函数。
该方法适合，无论结果如何都要进行的操作，例如清除数据。

• 语法：该回调函数的不接受任何参数；

    p.finally(onFinally);
  
    p.finally(function() {
     
    })