ES6 Promise 的这部分，起初我看《 JavaScript 高级程序设计 》4th 的时候看得云里雾里，说实话我不知道是不是因为该书第 4 版中文版的质量有所下降，讲得没那么清晰透彻了。后来我找到阮一峰老师的《 ES6 标准入门》重看了这部分，《 ES6 标准入门 》中的 Promise 这部分很合我的胃口，其中举的例子是真的好。PS：但《 ES6 标准入门 》我也认为有个小缺点——重点知识没有加粗（或者其他标记或者标记的重点较少），你必须仔细的看每一句话，不然你可能错过一个很重要的知识，或许该书是全程干货？
虽然我说是新手向，但我不想废话，所以本文还是假设你在其他地方看过 Promise 的内容，只是感觉没理解。或者其实这篇博客我只是想总结给我自己看？

构造函数

1. Promise 构造函数接受一个执行器（executor）函数作为参数。这个参数是必选的。

     let p = new Promise(() => {});
   

   这里给了一个空函数作为执行器函数也是可以的。

2. 这个执行器函数什么时候开始执行呢？它是异步执行的吗？

   let p = new Promise((resolve,reject) => {
     console.log('1: 这里是执行器函数啦');
   });
   console.log('2: Promise 实例化之后');
   console.log('3:', p);
   
   // 输出
   // 1: 这里是执行器函数啦
   // 2: Promise 实例化之后
   // 3: Promise { <pending> }
   

   所以我的结论是：执行器函数在实例化 Promise 时会被同步调用。
   我没看源码哈，我猜 Promise 构造函数大概长这样：

   function Promise(executor) {
     ...// 略去一万行~
     executor(resolve, reject);
     ...// 略
   }
   

   等我看了源码回来填坑。

3. 执行器函数的参数 resolve 和 reject。这两个参数很重要，关系到 Promise 的机制。

   • Promise 实例有三种可能的状态：pending(待定)、fulfilled（兑现，有时候也称为“解决”，resolved）、rejected（拒绝）。注意：浏览器控制台才能打印出 Promise 实例的状态。
   • 执行器函数的两个参数 resolve 和 reject 是两个函数，由 JS 引擎提供，不用自己部署。你也无法自己定义 resolve 和 reject。

     function myExecutor(resolve, reject) {
       console.log('这里是执行器，over');
     }
     
     let p = new Promise(myExecutor);
     
     // 这里是执行器，over
     

     这样写很清晰了吧，这里自己定义的 myExecutor 中的参数 resolve 和 reject 都是形参（你想怎么命名都可以哦），myExecutor 调用是由 JS 引擎完成的，所以实参只能由 JS 引擎给。稍微完善一下猜测的 Promise 构造函数：

     function Promise(executor) {
       ...// 略去一万行~
       let resolve = function () {
         ...// 这里便是 JS 引擎定义的 resolve 函数
       }
       let reject = function () {
         ...// 这里便是 JS 引擎定义的 reject 函数
       }
       executor(resolve, reject);
       ...// 略
     }
     

   • pending（待定）是 Promise 实例的最初始状态。在执行器函数中调用 resolve() 会把 Promise 实例状态切换为 fulfilled（解决），调用 reject() 会把状态切换为 rejected（拒绝）。另外，调用 reject() 也会抛出错误

     let p = new Promise((resolve,reject) => {
       console.log('1: 这里是执行器函数啦');
       // 执行器函数中调用 resolve 
       resolve();
     });
     console.log('2: Promise 实例化之后');
     console.log('3:', p);
     
     // 1: 这里是执行器函数啦
     // 2: Promise 实例化之后
     // 3: Promise {<fulfilled>: undefined}
     

     let p = new Promise((resolve,reject) => {
       console.log('1: 这里是执行器函数啦');
       // 执行器函数中调用 reject 
       reject();
     });
     console.log('2: Promise 实例化之后');
     console.log('3:', p);
     
     // 1: 这里是执行器函数啦
     // 2: Promise 实例化之后
     // 3: Promise {<rejected>: undefined}
     // 这里还有个 error : Uncaught (in promise) undefined
     

4. 为什么说 Promise 是目前主导性的异步编程机制？前面的例子中都没有出现异步操作。执行器函数是同步执行的，那么 Promise 的异步在哪？

   • 虽然执行器函数是同步执行的，但是可以用执行器函数把异步操作包裹起来。比如在执行器函数中调用 setTimeout()。

     let p = new Promise((resolve,reject) => {
       console.log('1');
       setTimeout(console.log, 0, '2');
       console.log('3');
     });
     console.log('4', p);
     setTimeout(console.log, 0, '5', p);
     
     // 1
     // 3
     // 4 Promise { <pending> }
     // 2
     // 5 Promise { <pending> }
     

     这里有 2 和 5 两个异步操作。

then 方法

1. 执行器函数中的异步操作触发 Promise 本身的异步。then 定义了 Promise 的状态变为 fulfilled 或 rejected 时的回调函数，这就是 Promise 本身的异步。执行器函数中执行的异步操作异步改变 Promise 实例的状态时，便触发了 Promise 的异步。Promise 居然是微任务，，，，，，我的理解要推翻重新理解了。。。。。

先写到这，待续