从整个的角度来说，Q的实现其实是闭包的一个应用，下文简单说明实现一下Q的基本功能。
GitHub Q的API
实现Q的功能，先了解一下Q的API
通过 https://github.com/kriskowal/q 截取最简单那部分的文档如下:
var deferred = Q.defer();
FS.readFile("foo.txt", "utf-8", function (error, text) {
if (error) {
deferred.reject(new Error(error));
} else {
deferred.resolve(text);
}
});
return deferred.promise;可以看到关键的api 有 defer, reject, promiss, resolve,然后文档还涉及到结果的取值，和错误捕捉，包括then, catch, done, 就不再贴出来。
入口
首先 从前四个api开始。 通过第一行代码
var deferred = Q.defer();那么可明显得出的代码是：
var Q = {
defer: function(){}
}然后defer()的返回值deffred拥有3个属性。
var Q = {
defer: function(){
return {
reject: function(error){},
resolve: function(data){},
promiss: null //当前还不能确定是个什么值
}
}
}以上基本的代码结构出来了。在来补充promiss的内容。
promiss
问来方便说明，这里先预设一个使用环境。从结果来推导代码实现。
var add = function(){
var deferred = Q.defer()
setTimeout(function(){
deferred.resolve(2)
}, 2000)
return deferred.promise
}
add().then(function(data){
console.log(data)
return data + 1
}).then(function(data){
console.log(data)
}).then(function(data){
throw new Error()
}).catch(function(err){
if(err){
console.log("There is a Error!")
console.log(err)
}
})
可以看到上面的add就使用了Q. 先看
add().then(...).then(...).catch(...)那么可以明确，deffred.promiss至少有三个属性 （then,catch两个加上没有出现的done）,并且其中的两个应该返回的是原对象。所以得到
var Q = {
defer: function(){
var promiss = {
then: function(fn){ //接收回调函数做为参数
// ... do something
return promiss
},
catch: function(fn){
//... do something
return promss
},
done: function(){}
}
return {
reject: function(error){},
resolve: function(data){},
promiss: promiss
}
}
}如此以上，整个Q的基本对象结构出来了。虽然没有实现。
then的实现
var add = function(){
var deferred = Q.defer()
setTimeout(function(){
deferred.resolve(2)
}, 2000)
return deferred.promise
}通过上述代码发现, 计算结果是异步的存储的，那么当结果计算完成后，then里面的函数应该执行。如下
var Q = {
defer: function(){
var promiss = {
then: function(fn){ //接收回调函数做为参数
// ... do something
return promiss //将自身对象返回很容易做到链式调用
},
...
}
return {
promiss: promiss
...
}
}
}所以
add() 返回值-> promiss
add().then() 返回值-> promiss接着来看 数据的传递。异步后resolve函数得到调用，获取到了实际结果，这个实际的返回值需要给then里面的回调函数。这个无法通过直接调用then来实现数据传递的。因此需要一个中间处理函数。如下：
var Q = {
defer: function(){
//定义一个结果处理函数。
var callResult = function(data){
//do some thing
};
var promiss = {
then: function(fn){ //接收回调函数做为参数
// ... do something
return promiss //将自身对象返回很容易做到链式调用
},
...
}
return {
resolve: function(data){
callResult(data)
}
...
}
}
}做到这里关键点来了，需要解决的问题有两个， 1.怎么在resolve 函数调用时，把结果传给then的回调，并且让它执行？ 2.then的返回值怎么需要给下一个then？
闭包的实现就在这里了。闭包的主要作用就是隔离作用域，以及向上层上下文寻找变量。
解决关键，使用个队列 来 存储所then的所有回调，在resolve执行时，执行这个队列里面的所有函数，并且把返回值循环赋值。
下面是完整的代码。
var Q = {
defer: function(){
‘use strict‘
//正常结果集
var resultQueue = [];
//错误处理句柄
var errorHandle = function(error){};
var promise = {
then: function(fn){
//存储每一个then的回调函数，进行统一处理
resultQueue.push(fn)
return promise
},
done: function(){
return {
catch: promise.catch
}
},
catch: function(fn){
errorHandle = fn
}
}
var callAllResultQueue = function(data){
for(var i = 0; i < resultQueue.length; i++){
data = resultQueue[i](data);
}
}
return {
resolve: function(data){
//resolve触发所有then回调函数的执行。
callAllResultQueue(data)
},
reject: function(error){
errorHandle(error)
}
promise: promise
}
}
}
var add = function(){
var deferred = Q.defer()
setTimeout(function(){
deferred.resolve(2)
}, 2000)
return deferred.promise
}
add().then(function(data){
console.log(data)
return data + 1
}).then(function(data){
console.log(data)
}).then(function(data){
throw new Error()
}).catch(function(err){
if(err){
console.log("There is a Error!")
console.log(err)
}
})