Promise原理解析

1、Promise 简介及使用

1.1、Promise 简介

Promise 对象是 CommonJS 工作组提出的一种规范，目的是为异步操作提供统一接口，它使得异步操作具备同步操作的接口，使得程序具备正常的同步运行的流程，回调函数不必再一层层嵌套。
Promise对象只有三种状态:
未完成：pending
已完成：resolved(也称fulfilled)
失败：rejected

以上三种状态只有以下两种变化,一旦当前状态变为“resolved”或“rejected”，就意味着不会再有新的状态变化
1、pending->resolved
2、pending->rejected

1.2 Promise使用方法

var promise = new Promise(function(resolve, reject) {
  // 异步操作，dosometing

  if (/*异步操作成功 */){
    resolve(value);
  } else {
    reject(error);
  }
});

Promise：为构造函数，接受一个函数作为参数，该函数接收resolve和reject两个参数，由JavaScript引擎提供，无需自己实现。

resolve：其作用是将Promise对象的状态从Pending变为Resolved,在异步操作成功时调用，并将异步操作的结果，作为参数传递出去；

reject：其作用是将Promise对象的状态从从Pending变为Rejected,在异步操作失败时调用，并将异步操作抛出的错误，作为参数传递出去

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

....

promise.then(function(value) {
  //异步操作成功时调用，value为异步操作的结果
}, function(error) {
  //异步操作失败时调用，error为抛出的错误
});

2、Promise实现原理

2.1、Promise构造函数

根据上面的内容我们知道，Promise初始状态为pending，其构造函数接受一个函数作为参数，该函数执行完同步或异步操作后，调用它的两个参数resolve和reject，为方便起见，我们给这个函数取个名字叫executor。

function Promise(executor) {
  var self = this
  self.status = 'pending' // 记录当前Promise的状态，初始为pending
  self.data = undefined  // 记录异步操作结果
  self.onResolvedCallback = [] // Promise resolve时的回调函数集
  self.onRejectedCallback = [] // Promise reject时的回调函数集

  function resolve(value) {
    // TODO
  }

  function reject(reason) {
    // TODO
  }

  try { //执行executor，使用try／catch捕获错误，
     executor(resolve, reject)
  } catch(e) {
     reject(e) //捕获到错误后reject
  }
}

2.2、resolve和reject实现

function Promise(executor) {
  // ...

  function resolve(value) {
    if (self.status === 'pending') {
      self.status = 'resolved'
      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)
      }
    }
  }

  // ...
}

可以看到，resolve和reject的实现几乎一样，都是将status由pending改为另一个状态，并执行对应的回调函数

2.3、then方法

Promise对象中有一个then方法，用来注册在这个Promise状态确定后的回调，then方法会返回一个Promise，关于这一点，Promise/A+标准并没有要求返回的这个Promise是一个新的对象，但在Promise/A标准中，明确规定了then要返回一个新的对象。我们把then方法写在原型链上。

Promise.then = function(resolved, rejected) {
    var self = this;
    var promise2 = null;
    // 根据标准，如果then的参数不是function，则我们需要忽略它，此处以如下方式处理
    resolved = typeof resolved === 'function' ? resolved : function(v) {}
    rejected = typeof rejected === 'function' ? rejected : 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
        })
    }
}

上述代码根据当前status执行不同的操作，下面完善上述代码

Promise.then = function(resolved, rejected) {
    var self = this;
    var promise2 = null;
    // 根据标准，如果then的参数不是function，则我们需要忽略它，此处以如下方式处理
    resolved = typeof resolved === 'function' ? resolved : function(v) {return v}
    rejected = typeof rejected === 'function' ? rejected : function(r) { return r}


    if (self.status === 'resolved') {
        return promise2 = new Promise(function(resolve, reject) {
            try{
                var x=resolved(self.data)
                if(x instanceof Promise){
                    x.then(resolve, reject)
                }
                resolve(x)
            }catch(err){
                reject(err)
            }
        })
    }

    if (self.status === 'rejected') {
        return promise2 = new Promise(function(resolve, reject) {
            try{
                var x=rejected(self.data)
                if(x instanceof Promise){
                    x.then(resolve, reject)
                }
            }catch(err){
                reject(err)
            }
        })
    }

    if (self.status === 'pending') {
        return promise2 = new Promise(function(resolve, reject) {
            self.onResolvedCallback.push(function(value){
                try{
                    var x=resolved(self.data)
                    if(x instanceof Promise){
                        x.then(resolve, reject)
                    }
                    resolve(x)
                }catch(err){
                    reject(err)
                }
            })

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

2.4、catch方法

最后我们加上catch函数

// 为了下文方便，我们顺便实现一个catch方法
Promise.prototype.catch = function(rejected) {
  return this.then(null, rejected)
}

以上只是Promise原理的简单实现，仅供学习讨论
参考链接：
1、剖析Promise内部结构
2、Promise