自己经常使用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()
