学习Promise

2016-10-29 本文已影响0人狐尼克朱迪

自己经常使用Promise，但是对其实现和标准一知半解。本文从标准和实现出发，探究下它到底干了什么。

定义

Promise是一种异步编程的解决方案，可以让我们脱离异步回调的噩梦。我们可以把它看做一个容器，里面存放着未来才会结束的事件（如异步回调）的结果。

基本用法

下面是一个使用Promise进行ajax请求的例子：

var getJSON = function(url) {
  var promise = new Promise(function(resolve, reject){
    var client = new XMLHttpRequest();
    client.open("GET", url);
    client.onreadystatechange = handler;
    client.responseType = "json";
    client.setRequestHeader("Accept", "application/json");
    client.send();

    function handler() {
      if (this.readyState !== 4) {
        return;
      }
      if (this.status === 200) {
        resolve(this.response);
      } else {
        reject(new Error(this.statusText));
      }
    };
  });

  return promise;
};

getJSON("/posts.json").then(function(json) {
  console.log('Contents: ' + json);
}, function(error) {
  console.error('出错了', error);
});

getJson 方法返回一个Promise对象，通过then完成对请求结果的处理。

标准

Promise的标准可以参见：Promise标准，总结起来有以下几条：

Promise有三种状态：pending、fulfilled、rejected。pending是初始状态，Promise可以由pending 转成 fulfilled 或者 rejected 。当Promise不是pending 状态时，其状态不能进行改变，也就是说不可能由fulfilled或rejected状态转成其它状态。
Promise必须提供一个then方法。then有两个可选参数：resolve 和 reject。只有当Promise进入fulfilled状态时才会执行resolve方法；同理进入rejected状态时才会执行reject方法。 then返回的是一个新的Promise对象，而不是this（原因：Promise进入非pending状态后，不能再改变状态！）。
不同Promise的实现可以相互调用。相互调用的准则见标准页面的2.3这一条。

实现

Promise的实现有很多：Es6、kriskowal/q等。我们尝试实现一个基本的Promise。

构造函数

定义一个Promise函数，参数为executor。定义初始状态为pending，同时提供两个函数resolve和reject作为参数供executor函数调用：

function Promise(executor) {
  var self = this;

  // 初始状态
  self.status = 'pending';

  // Promise resolve时的回调函数集，在Promise结束之前有可能有多个回调添加到它上面
  self.onResolvedCallback = [];
  // Promise reject时的回调函数集，因为在Promise结束之前有可能有多个回调添加到它上面
  self.onRejectedCallback = [];

  // resolve
  function resolve(value) {
    // todo
  }

  // reject
  function reject(reason) {
    // todo 
  }

  // 考虑到执行executor的过程中有可能出错，所以用try/catch块给包起来，并且在出错后以catch到的值reject掉这个Promise
  try {
    executor(resolve, reject);
  } catch (reason) {
    reject(reason);
  }
}

resolve和reject函数

resolve函数执行时，会把Promise状态由pending 转成 fulfilled；reject函数执行时，会把Promise状态由pending 转成 rejected。两个函数执行时，需要把加到Promise上的方法执行：

function Promise(executor) {
  // ...
  
  function resolve(value) {
    if (value instanceof Promise) {
        return value.then(resolve, reject)
    }
    setTimeout(function() { // 异步执行所有的回调函数
        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) {
    setTimeout(function() { // 异步执行所有的回调函数
        if (self.status === 'pending') {
            self.status = 'rejected'
            self.data = reason
            for (var i = 0; i < self.onRejectedCallback.length; i++) {
                self.onRejectedCallback[i](reason)
            }
        }
    })
}

  // ...
}

then函数

then 函数返回一个Promise对象，有两个参数：onResolved 和 onRejected。它根据当前Promise的状态分开进行处理：

当前为resolved，直接调用onResolved
当前为reject，直接调用onRejected
当前为pending，并不能确定调用onResolved还是onRejected，只能等到Promise的状态确定后，才能确实如何处理。

// then函数
Promise.prototype.then = function(onResolved, onRejected) {
  var self = this;
  var promise2;

  // resolve函数 如果不定义采用空函数
  onResolved = typeof onResolved === 'function' ? onResolved : function(v) {
    return v
  }
  // reject函数 如果不定义采用空函数
  onRejected = typeof onRejected === 'function' ? onRejected : function(r) {
    throw r
  }

  // 分三个状态进行处理
  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的结果
      }
    })
  }

  // 此处与前一个if块的逻辑几乎相同，区别在于所调用的是onRejected函数，就不再做过多解释
  if (self.status === 'rejected') {
    return promise2 = new Promise(function(resolve, reject) {
      try {
        var x = onRejected(self.data)
        if (x instanceof Promise) {
          x.then(resolve, reject)
        }
      } catch (e) {
        reject(e)
      }
    })
  }

  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的调用

这个部分参考协议，具体实现如下：

function resolvePromise(promise2, x, resolve, reject) {
  var then
  var thenCalledOrThrow = false

  if (promise2 === x) {
    return reject(new TypeError('Chaining cycle detected for promise!'))
  }

  if (x instanceof Promise) {
    if (x.status === 'pending') { //because x could resolved by a Promise Object
      x.then(function(v) {
        resolvePromise(promise2, v, resolve, reject)
      }, reject)
    } else { //but if it is resolved, it will never resolved by a Promise Object but a static value;
      x.then(resolve, reject)
    }
    return
  }

  if ((x !== null) && ((typeof x === 'object') || (typeof x === 'function'))) {
    try {
      then = x.then //because x.then could be a getter
      if (typeof then === 'function') {
        then.call(x, function rs(y) {
          if (thenCalledOrThrow) return
          thenCalledOrThrow = true
          return resolvePromise(promise2, y, resolve, reject)
        }, function rj(r) {
          if (thenCalledOrThrow) return
          thenCalledOrThrow = true
          return reject(r)
        })
      } else {
        resolve(x)
      }
    } catch (e) {
      if (thenCalledOrThrow) return
      thenCalledOrThrow = true
      return reject(e)
    }
  } else {
    resolve(x)
  }
}

扩展

现行的Promise都进行了扩展，如引入了catch、cancel、stop等方法。它们的实现也比较简单，基于这个进行展开：

Promise.prototype.catch = function(onRejected) {
  return this.then(null, onRejected)
}

Promise.cancel = Promise.stop = function() {
    return new Promise(function() {}) 
}

总结

在参考文章2里作者举出了三个问题，具体可以查阅问题，在此罗列下：

性能问题：由于setTimeout的执行时间间隔(4ms)，如果Promise过长，会影响执行快慢
停止一个Promise链：可以返回一个空的Promise，维持在pending状态；但这样会造成垃圾不会回收。

  new Promise(function(resolve, reject) { 
  resolve(42) 
}).then(function(value) { 
  // "Big ERROR!!!" 
  return new Promise(function(){}) 
})

Promise链上最后一个then出错：现行的框架采用引入done函数，也可以通过onRejectedCallback数组的长度判断是不是最后一个Promise。

Promise.prototype.done = function(){
return this.catch(function(e) { // 此处一定要确保这个函数不能再出错
  console.error(e)
})
}

function reject(reason) {
setTimeout(function() {
  if (self.status === 'pending') {
    self.status = 'rejected'
    self.data = reason
    if (self.onRejectedCallback.length === 0) {
      console.error(reason)
    }
    for (var i = 0; i < self.rejectedFn.length; i++) {
      self.rejectedFn[i](reason)
    }
  }
})
}

参考

Promise标准
 剖析Promise内部结构，一步一步实现一个完整的、能通过所有Test case的Promise类
 Speed up your Websites with a Faster setTimeout using soon()