本文就是从MDN中copy的，仅为了自己复习方便。

1、 executor

new Promise( function(resolve, reject) {...} /* executor */  );

executor是带有 resolve和reject两个参数的函数 。Promise构造函数执行时立即调用executor 函数， resolve 和 reject 两个函数作为参数传递给executor（executor 函数在Promise构造函数返回所建promise实例对象前被调用）。
resolve和和 reject函数被调用时，分别将promise的状态改为fulfilled（完成）或rejected（失败）。executor 内部通常会执行一些异步操作，一旦异步操作执行完毕(可能成功/失败)，要么调用resolve函数来将promise状态改成fulfilled，要么调用reject 函数将promise的状态改为rejected。如果在executor函数中抛出一个错误，那么该promise 状态为rejected。executor函数的返回值被忽略。
(resolve和reject函数是promise内部自己提供的）

function myAsyncFunction(url) {
  return new Promise((resolve, reject) => {
    const xhr = new XMLHttpRequest();
    xhr.open("GET", url);
    xhr.onload = () => resolve(xhr.responseText);
    xhr.onerror = () => reject(xhr.statusText);
    xhr.send();
  });
};

2、Promise

Promise 对象是一个代理对象（代理一个值），被代理的值在Promise对象创建时可能是未知的。它允许你为异步操作的成功和失败分别绑定相应的处理方法（handlers）。 这让异步方法可以像同步方法那样返回值，但并不是立即返回最终执行结果，而是一个能代表未来出现的结果的promise对象。
一个 Promise有以下几种状态:

• pending: 初始状态，既不是成功，也不是失败状态。
• fulfilled: 意味着操作成功完成。
• rejected: 意味着操作失败。
  pending 状态的 Promise 对象可能会变为fulfilled 状态并传递一个值给相应的状态处理方法，也可能变为失败状态（rejected）并传递失败信息。当其中任一种情况出现时，Promise 对象的 then 方法绑定的处理方法（handlers ）就会被调用.

3、 Promise.prototype

• Promise.prototype.then(onFulfilled, onRejected)：当Promise状态变为fulfilled时，调用 then 的 onfulfilled 方法，当Promise状态为rejected时，调用 then 的 onrejected 方法， 所以在异步操作的完成和绑定处理方法之间不存在竞争）。
• Promise.prototype.catch(onRejected)
• Promise.prototype.finally(onFinally)

三者都会返回一个新的Promise。

4、方法

4.1 Promise.resolve(value)

如果参数value是一个Promise对象，则直接返回这个Promise对象。如果不是转化为value.

4.2 Promise.reject()

返回一个带有拒绝原因的Promise对象。

4.3 Promise.all()

返回一个 Promise对象用于表示一个异步操作的最终完成 (或失败), 及其结果值.") 实例，此实例在 iterable 参数内所有的 promise 都“完成（resolved）”或参数中不包含 promise 时回调完成（resolve）；如果参数中 promise 有一个失败（rejected），此实例回调失败（reject），失败原因的是第一个失败 promise 的结果。

var promise1 = Promise.resolve(3);
var promise2 = 42;
var promise3 = new Promise(function(resolve, reject) {
  setTimeout(resolve, 100, 'foo');
});

Promise.all([promise1, promise2, promise3]).then(function(values) {
  console.log(values);
});

实现：

/ 添加静态all方法
function all (list) {
  return new Promise((resolve, reject) => {
    //返回每个Promise值的集合
    let values = []
    let count = 0
    for (let [i, p] of list.entries()) {返回一个解析过带着给定值的Promise对象，如果参数是一个Promise对象，则直接返回这个Promise对象。
      // 数组参数如果不是Promise实例，先调用Promise.resolve
      Promise.resolve(p).then(res => {
                                                    values[i] = res
                                                    count++
                                                      // 所有状态都变成fulfilled时返回的Promise状态就变成fulfilled
                                                   if (count === list.length) resolve(values)
                                            }, err => {  // 有一个被rejected时返回的MyPromise状态就变成rejected                        
                                                     reject(err)
                                           })
    }
  })
}

4.4 Promise.race(iterable)

Promise.race(iterable) 方法返回一个 promise，一旦迭代器中的某个promise解决或拒绝，返回的 promise就会解决或拒绝。

function race(list){  //实现race
    return new Promise( (resolve, reject) =>{
         int count = 0;
        for (let [i, p] of list.entries()) { //返回一个解析过带着给定值的Promise对象，如果参数是一个Promise对象，则直接返回这个Promise对象。
            Promise.resolve(p).then((res) =>{
                                                     resolve(res);
                                           }, (err) = >{
                                                  reject(err);
          })
        }
   }
}