Javascript 实现一个简易的Promise

为什么会有Promise

由于历史原因导致了 Promise 没出现之前编写 JavaScript 代码不得不面对如下场景，该场景被称为回调地狱，它使得编写和维护代码变得十分冗长并且难以调试，这一情况困扰了 javascript 程序员相当长的时间，直到 Promise 的出现。

function a(
  function b(function c(···){
    // 代码块c
  }){
    // 代码块b
  }){
  // 代码块a
}

Promise 是如何被构想出来的

如今我们已经用惯了 Promise ，可这样的一套方法是如何被构想出来的呢？
试想创造一个对象，首先这个对象接受一个executor立即执行函数（最开始的一段逻辑），我们这个对象会将这个立即执行函数的执行结果进行跟踪，假设执行成功与失败的标志分别为‘resolved’和‘reject’和其对应的值（data），默认为‘pending’状态，我们根据这个结果进行后续的操作，同时构造函数记录了该Promise对象的回调函数集，这个构造函数取名为Promise。

同时，executor也要传入两个函数作为实参，分别是执行成功和失败的处理，得到Promise的结构大致如下：

function Promise(executor){
  var self = this
  self.status = 'pending' // Promise当前的状态
  self.data = undefined  // Promise的值
  self.onResolvedCallback = [] // Promise resolve时的回调函数集，因为在Promise结束之前有可能有多个回调添加到它上面
  self.onRejectedCallback = [] // Promise reject时的回调函数集，因为在Promise结束之前有可能有多个回调添加到它上面

  executor(resolve, reject) // 执行executor并传入相应的参数
}

还有两个问题：
1.executor可能执行过程会出错
2.传入executor的两个函数还未定义
完善一下：

function Promise(executor){
  var self = this
  self.status = 'pending' // Promise当前的状态
  self.data = undefined  // Promise的值
  self.onResolvedCallback = [] // Promise resolve时的回调函数集，因为在Promise结束之前有可能有多个回调添加到它上面
  self.onRejectedCallback = [] // Promise reject时的回调函数集，因为在Promise结束之前有可能有多个回调添加到它上面
  function resolve(){
      // TODO
  }
  function reject(){
      // TODO
  }
  try(
    executor(resolve, reject) // 执行executor并传入相应的参数
  )catch(e){
    reject(e)
  }

}

接下来来实现resolve和reject:

  function resolve(value){
    if(self.status === 'pending'){
      self.status = 'resolve'
      self.data = value
      for(var i = 0; i < self.onResolvedCallback.length; i++）{
        self.onResolvedCallback[i](value)
      }
    }
  }
   function reject(reason) {
    if (self.status === 'pending') {
      self.status = 'rejected'
      self.data = reason
      for(var i = 0; i < self.onRejectedCallback.length; i++) {
        self.onRejectedCallback[i](reason)
      }
    }
  }
}

梳理下逻辑：判断状态为pending之后把状态改为相应的值，并把对应的value和reason存在self的data属性上面。

then方法

接着往下，这个Promise还应该有一个状态确定后注册回调的then方法,这个方法也应该返回一个Promise对象用来实现链式调用（.then().then()...）

// then方法接收两个参数，onResolved，onRejected，分别为Promise成功或失败后的回调
Promise.prototype.then = function(onResolved, onRejected) {
  var self = this
  var promise2

  // 根据标准，如果then的参数不是function，则我们需要忽略它，此处以如下方式处理
  onResolved = typeof onResolved === 'function' ? onResolved : function(v) {}
  onRejected = typeof onRejected === 'function' ? onRejected : function(r) {}

  if (self.status === 'resolved') {
    return promise2 = new Promise(function(resolve, reject) {
        //TODO
    })
  }

  if (self.status === 'rejected') {
    return promise2 = new Promise(function(resolve, reject) {
        //TODO
    })
  }

  if (self.status === 'pending') {
    return promise2 = new Promise(function(resolve, reject) {
        //TODO
    })
  }
}

Promise总共有三种可能的状态，我们分三个if块来处理，在里面分别都返回一个new Promise。
接下来思考promise2的data和status应该怎样去处理？
这里有一点非常重要，就是promise1里的onResolved/onRejected也有可能是一个promise，这个时候就需要递归地去判断上一个promise的的onResolved/onRejected是否是promise,直到它不是promise为止。
我画了张示意图来说明当上一个promise的status是'resolved'的时候的处理：

promise1.png

代码如下：

···
  if (self.status === 'resolved') {
    // 如果promise1(此处即为this/self)的状态已经确定并且是resolved，我们调用onResolved
    // 因为考虑到有可能throw，所以我们将其包在try/catch块里
    return promise2 = new Promise(function(resolve, reject) {
      try {
        var x = onResolved(self.data)
        if (x instanceof Promise) { // 如果onResolved的返回值是一个Promise对象，直接取它的结果做为promise2的结果
          x.then(resolve, reject)
        }
        resolve(x) // 否则，以它的返回值做为promise2的结果
      } catch (e) {
        reject(e) // 如果出错，以捕获到的错误做为promise2的结果
      }
    })
  }
···

当status为'rejected'的时候逻辑也是类似，但是当status为'pending'的时候呢？
记得我们在Promise构造函数里定义了两个回调函数集onResolvedCallback和onRejectedCallback，到目前为止，集合里的内容还没有被添加。而这两个集合里的函数是在resolved和rejected函数里依次执行的，而resolved和rejected函数是在构造函数里用try```catch的方式传入executor的，那我们怎么知道这个executor是执行成功的呢？
回想起上小学的时候数学老师教我们的，假设法。假设执行成功了，就要执行执行成功的回调函数集，失败率就执行失败的回调函数集。于是我们就在then方法的if(self.status === 'pending')的时候处理，代码就会变成这样：

if (self.status === 'pending') {
  // 如果当前的Promise还处于pending状态，我们并不能确定调用onResolved还是onRejected，
  // 只能等到Promise的状态确定后，才能确实如何处理。
  // 所以我们需要把我们的**两种情况**的处理逻辑做为callback放入promise1(此处即this/self)的回调数组里
  // 逻辑本身跟第一个if块内的几乎一致，此处不做过多解释
    return promise2 = new Promise(function(resolve, reject) {
      self.onResolvedCallback.push(function(value) {
        try {
          var x = onResolved(self.data)
          if (x instanceof Promise) {
            x.then(resolve, reject)
          }
        } catch (e) {
          reject(e)
        }
      })

      self.onRejectedCallback.push(function(reason) {
        try {
          var x = onRejected(self.data)
          if (x instanceof Promise) {
            x.then(resolve, reject)
          }
        } catch (e) {
          reject(e)
        }
      })
    })
  }
}

结合promise.then的简单的示意图：

promise链式.png

说明

至此，一个不完整的Promise对象就创建完成了，实现方法来源于知乎,更多的细节请戳：史上最易读懂的 Promise/A+ 完全实现，本文添加了示意图帮助理解。