ES6中promise如何实现

摘要：这下不管是同步还是异步，我们随时可以在方法中去取值，如果值没有被，也就是说状态没发生变化，将给我们记录下这件事，等到的那个时间点把值传给方法中那个回调函数，。

顾名思义，promise中文意思就是承诺，也就是现在实现不了将来•••••，但是将来这玩意谁说的准呢。就像你去泡妞，你可能许下各种诺言，但能不能实现，完全取决于你这人靠不靠谱。好在计算机不是人，不是人，不是人，••••正因为不是人，所以它许下的承诺，它就一定会给你一个结果。
等待承诺实现的过程中很漫长，所以你可以做一些其它的事情，没必要老是堵在这一条道上，也就是异步。打个比方，你打电话给饭店老板叫了个外卖，老板告诉你，10分钟后送过去，也就是说老板给了你一个承诺，于是你等啊等，这中间又去上了个厕所，玩了会手机••••••，这就是异步，老板给的承诺并没有妨碍你干其它的事情。OK，扯淡结束。

为了实现异步，一般要设置一个回调函数

</>复制代码 
setTimeout(function(){
    console.log(1);
    setTimeout(function(){
        console.log(2);
        setTimeout(function(){
            console.log(3);
            setTimeout(function(){
                console.log(4);
                setTimeout(function(){
                    console.log(5);
                },500)
            },400)
        },300)
    },200)
},100);

••••••有没有一种想死的感觉！
promise最大优势就是第一消灭了这种回调地狱，第二增加了错误捕获，像下面这种，

</>复制代码 
promis.then(function (response) {
    //do something;
}, function (reason) {
    //get error
}).then(function (response) {
    //do something;
}, function (reason) {
    //get error
}).then(function (response) {
    //do something;
}, function (reason) {
    //get error
});

如果不做错误处理则更清晰

</>复制代码 
promis.then(function (response) {
    //do something;
}).then(function (response) {
    //do something;
}).then(function (response) {
    //do something;
}).then(function (response) {
    //do something;
});

它使得异步的代码看起来像是在同步执行，大大增强了代码的可读性。
美中不足的是你得写一堆的.then(function(){},function(){})，但是和回调地狱相比，忍了。
在ES7中会有号称是异步的终极解决方案，async和await，那是后话。

前面说了，计算机不是人，所以它许下的承诺，它一定会给你一个结果，不管这个承诺的结果是接受还是拒绝。
所以，第一，promise一定会返回一个结果。
第二，这个结果是不可逆的，你只能接受，本质是因为promise的状态不可逆，一旦它变成了resolve或者reject，你休想再让你变成pending，否则，它要会说话，肯定回你的只有一个字，滚！
第三、promise的结果什么时候返回，你说了不算，你去泡妞的时候，妞也不一定当场就答应你吧，或许想个三、五天也说不定，这个主动权不是掌握在你手中的。
第四、ES6的promise执行过程中，你是无法获得执行的进度的，到底它现在是pending还是resolve，还是reject。就好像妞和她的闺蜜探讨要不要接受你，你是打听不到的。当然并不是完全不能，例如angularjs的$q实现一个notify方法，可以获取到执行进度的通知。
最后说一点儿你的权力，你能决定的是在什么时候去取promise的结果，也就是调用then方法的时间，就好像你每天追着妞问，你想好没有••••••，妞这个时候会有三种回答，一是答应你，二是拒绝你，三是还得再想想，XXXX时候再告诉你••••，也就说这TMD又是一个承诺•••••。
咳、咳，现在开始必须严肃点，毕竟技术是一件严肃的事情。

说白了，promise就是一个对象，一个只能通过then方法来取得它上面的值的对象。
在es6中，你只要大喊一句，妞，给我个承诺，它就会给你一个promise，就像下面这样：

</>复制代码 
var promise = new Promise(function(resolve,reject){
    //do something;
})

然后你就可以调用它的then方法去取值，那么从这个角度看，这个构造函数一定是返回了一个带有then方法的对象。另外还有状态，状态的变化不可逆。再加上些其它的方法，如all、catch•••，不过不要着急，我们一步一步来意淫出这个漂亮的妞••••
1、通常情况，我们使用回调一个函数内执行另外一个函数：

</>复制代码 
function doSomething(callback){
    console.log("do something");
    callback();
}
doSomething(function(){
    console.log("a");
});

2、但是在使用promise时，我们是用then方法去取结果，而promise就是个对象，那么上面的代码看起来应该这样写：

</>复制代码 
function doSomething(){
    console.log("a");
    return {
        then: function(callback){
            var value = 1;
            callback(value);
        }
    }
}
doSomething().then(function(res){
    console.log(res);
});

在这里，我们调用dosomething函数时，返回了一个带有then方法的对象，然后在then方法回调中去执行，现在看来是不是有那么点样子了，时刻记得两件事，对象， then方法。
3、在ES6中Promise是一个构造函数，这简单，给这个dosomething换个名字，

</>复制代码 
function Promise(){
    this.then = function(callback){
        var value = 1;
        callback(value);
    }
}

在实例化promise的时候，要传一个函数进去，这也简单

</>复制代码 
function Promise(fn){
    this.then = function(callback){
        callback();
    }
}

实例化传入的函数fn中(下文中的fn都是指代这个匿名函数)，你会传入2个参数，一个叫resolve，另一个叫reject，为了简单起见，我们不考虑reject，它的道理和resolve是一样的。那么就像这样：

</>复制代码 
var promise = new Promise(function(resolve){
    var value = 1;
    resolve(value);
})

即然传了一个fn函数进去，那么在实例化过程中，这个函数一定会在某个时刻执行。执行时，它又会接收到一个参数resolve，这个resolve一定是一个函数，这点从上面就可以很明显的看出来，resolve在实例化时执行了，而且接收到了一个参数，在这里是变量value。那么Promise函数内部很可能是这样：

</>复制代码 
   function Promise(fn){
        function resolve(value){}
        this.then = function (onResolved) {};
        fn(resolve);
  }

为了看起来更直接，这里我们把调用then方法传的第一个函数就叫做onResolved，那么接下来我们应该考虑在实例化的时候，还有什么事情要做，在then方法的回调函数中我们希望得到promise的值，这个值是在fn函数调用后被resolve函数运算后得到的，最终要在onResolved函数中拿到，也就是说，我们必须在resolve中将这个值传递给onResolved，迂回一下：

</>复制代码 
function Promise(fn) {
  var callback = null;
  function resolve(value) {
      callback(value);
  }
  this.then = function(onResolved) {
    callback = onResolved;
  };
  fn(resolve);
}

但是这里有一个问题，就是我们调用resolve方法时，还没有调用过then方法，因此callbak是null，浏览器报错：callback is not a function，这里hack下，让resolve方法的执行在then之后。

</>复制代码 
  function Promise(fn) {
        var callback = null;
        function resolve(value) {
            setTimeout(function(){
                callback(value);
            },0)
        }
        this.then = function(onResolved) {
            callback = onResolved;
        };
        fn(resolve);
    }

执行一下，

</>复制代码 
var promise = new Promise(function(res){
    var value = 2;
    res(2);
});
promise.then(function(res){
    console.log(res);
})

OK，成功的输出。目前为止，promise的轮廓算是被我们意淫出来了。
4、promise是有状态的，而且状态不可逆，同样的为了简单起见，我先来搞定从pending变到resolved，那么rejected也一样。仔细想下，执行了resolve方法后可以得到一个resolved状态的值，那么必然在resolve方法中会去改变promise的状态，并且得到这个值，那么代码貌似应该这样写：

</>复制代码 
 function Promise(fn) {
    var state = "pending";
    function resolve(newValue) {
        state = "resolved";
        callback(newValue);
    }
    this.then = function(onResolved) {
        callback = onResolved;
   };
    fn(resolve);
 }

这里我们先把setTimeout这家伙给干掉了，因为我们加入了状态，也就意味我们是想通过状态的变化来知道能不能得到值，那么问题来了，我们不知道状态啥时候变，就像你不知道你要泡的妞啥时候答应你一样，你只能追问，万一妞没想好，她很可能再给你一个承诺，就是那个该死的XXX时候再告诉你，不过好歹她也算给了你一个等待的机会，而我们现在要做的就是创造这么个机会。

</>复制代码 
function Promise(fn) {
  var state = "pending";
  var value;
  var deferred;
  function resolve(newValue) {
    value = newValue;
    state = "resolved";
    if(deferred) {
      handle(deferred);
    }
  }
  function handle(onResolved) {
    if(state === "pending") {
      deferred = onResolved;
      return;
    }
    onResolved(value);
  }
  this.then = function(onResolved) {
    handle(onResolved);
  };
  fn(resolve);
}

这里引入了另外一个函数handle，至此可以说promise的最关键的东西我们已经看到了，妞的身材逐渐显现。又扯远了•••••
仔细看下除了handle我们还引入两个变量value和deferred，先从最简单的来：
value的作用很简单，在构造函数内它是一个全局变量，起到一个桥梁作用，就是为了在handle函数内能取到newValue的值，而newValue就是fn函数里的那个结果。
handle我们估且可以认为它是妞的一个管家，它会去替我们询问妞有没有想好，也就是去判断当前这个承诺的状态，再决定怎么做。
deferred我们估且可以这样理解，它就是管家的一个记事本，你隔三差五的去问，它老人家不得记下来，如果一不小心忘了，那就悲催了。
这下不管是同步还是异步，我们随时可以在then方法中去取值，如果值没有被resolve，也就是说状态没发生变化，deferred将给我们记录下这件事，等到resolve的那个时间点把值传给then方法中那个回调函数，onResolved。
在这里请默念一百遍handle，defer，再接着往下看，我保证他们会让你困惑。
5、回到最初，为什么要用promise，想想回调地狱，再想想promise是怎么解决的，那就是then方法链式调用。
能够实现链式调用，也就是说then方法返回的值也一定是个promise，这样你才能.then，.then的一直写下去。废话不说，没代码说个毛：

</>复制代码 
function Promise(fn) {
  var state = "pending";
  var value;
  var deferred = null;
  function resolve(newValue) {
    value = newValue;
    state = "resolved";
    if(deferred) {
      handle(deferred);
    }
  }
  function handle(handler) {
    if(state === "pending") {
      deferred = handler;
      return;
    }
    if(!handler.onResolved) {
      handler.resolve(value);
      return;
    }
    var ret = handler.onResolved(value);
    handler.resolve(ret);
  }
  this.then = function(onResolved) {
    return new Promise(function(resolve) {
      handle({
        onResolved: onResolved,
        resolve: resolve
      });
    });
  };
  fn(resolve);
}

这下换个姿势，我们先啃硬货。我们让then方法返回了一个promise，而且这个promise实例化时传入的函数里调用了handle函数，传入了一个对象，onResolved很显然就是then方法里第一个函数，没什么可说的。关键是这handle和resolve是哪个？思考1分钟。
这里我们用setTimeout简单模拟一个异步，拿一个then看下，发生了什么：

</>复制代码 
var promise = new Promise(function(resolve){
    setTimeout(function(){
        resolve(1);
    },3000)
});
promise.then(function(res){
    console.log(res);
})

首先我们去new一个promise，在实例化的过程中，调用了传进的那个函数，3秒后才能执行到resolve，紧接着调用了它的then方法，这个时候由于promise的状态没变，肯定取不到值，好在then方法会返回个promise，于是又执行了一次promise的实例化过程。这里无法回避的就是作用域的问题，这个关系到handle函数执行在哪个环境中，参数的到底从哪个地方获取到，另外就是强大的闭包。相关知识不解释。
为了看的更清楚，我们加入一些标记，到chrome的控制台中调试下:

</>复制代码 
var count = 0;
function Promise(fn) {
    var state = "pending";
    var value;
    var deferred = null;
    var scope = ++count;
    function resolve(newValue) {
        value = newValue;
        state = "resolved";
        console.log("resolve: I am in " +scope);
        if(deferred) {
            handle(deferred);
        }
    }
    function handle(handler) {
        console.log("handle: I am in " +scope);
        if(state === "pending") {
            deferred = handler;
            return;
        }
        if(!handler.onResolved) {
            handler.resolve(value);
            return;
        }
        var ret = handler.onResolved(value);
        handler.resolve(ret);
    }
    this.then = function(onResolved) {
        console.log("then: I am in " + scope);
        return new Promise(function(resolve) {
            console.log("then promise: I am in " + scope);
            handle({
                onResolved: onResolved,
                resolve: resolve
            });
        });
    };
    fn(resolve);
}
var promise = new Promise(function(resolve){
    setTimeout(function(){
        resolve(1);
    },3000)
});
promise.then(function(res){
    console.log(res);
});

加入的scope是为了监视作用域的变化，以间接反应出我们调用handle时是在哪个作用域上查询到的，此外我们还需要监视state和deferred的变化。
主要看then调用之后，废话不说上图：
5-1、在执行then方法的时候，scope=1，state，deferred不可用。由于模拟了异步，这个时候第一个promise的resolve方法并没有执行，这里模拟了3秒，实际情况下，比如ajax取数据时，我们并不知道这个准确的时间，就像开始时说的，这妞啥时候答应你，主动权不在你手中，由妞说了算。

5-2、接下来去实例化then方法创建的这个promise，scope = 2，state=”pending”，deferred=null。

5-3、在实例化完成之后，此时去执行fn函数，scope=1，state，deferred不可用。

第一，函数的作用域是在定义时就生成的，而不是在调用的时候。第二个promise定义的时候，是在第一个promise作用域上，这样即使它被return了出去，由于闭包的特性，仍读取的是第一个作用域上值，所以这里的handle必定是第一个promise的handle。而resolve则不同，它是作为行参传递了进来，所以这里的resolve是第二个promise的resolve。
5-4、进入handle时，scope = 1，state =” pending”，deferred保存了参数。

5-5、3秒时间到，第一个promise里的resolve被执行了，也就是说拿到了结果，这时候，scope=1,state = “resolved”，deferred保存着刚才传进来的那个对象，再次进入handle函数。

5-6、scope=1,state = “resolved”，deferred求值为true，因此肯定会继续执行。下面添加的这段代码在这里也就很清楚了，假如then方法中没有传进来的onResolved函数，这里的value将直接交给下一个then方法中的onResolved函数使用，避免一些无聊的人像这样去调用：

</>复制代码 
promise.then().then().then(function(res){
    console.log(res);
})

正常人都会让value在onResolved函数中接收到，然后ret就是onResolved函数的返回值，这里没有return回的值，所以ret肯定是undefined。

5-7、scope=2,state = “resolved”，deferred=null。这里的resolve是第个promise的resolve，所以定义的时候就是在作用域2上，如果后面再调用then方法，生成新的promise，这时就会将undefined作为第二个promise的值传递下去。

这里再次强调一下，handle方法和deferred是核心所在，其背后的精髓无非还是作用域和闭包的巧妙设计。变量的读取必定先从自身所处作用域开始，如果自身作用域上读不到，才会一级一级向上访问。
6、意淫到这里基本上核心的东西就差不多了，下面我们来加上reject时的情况，直接上代码：

</>复制代码 
function Promise(fn) {
    var state = "pending";
    var value;
    var deferred;
    this.then = function (onResolved, onRejected) {
        return new Promise(function (resolve, reject) {
            handle({
                onResolved: onResolved,
                onRejected: onRejected,
                resolve: resolve,
                reject: reject
            });
        });
    };
    function resolve(newValue) {
        if (newValue && typeof newValue.then === "function") {
            newValue.then(resolve);
            return;
        }
        state = "resolved";
        value = newValue;
        if (deferred) {
            handle(deferred);
        }
    }
    function reject(reason) {
        state = "rejected";
        value = reason;
        if (deferred) {
            handle(deferred);
        }
    }
    function handle(handler) {
        if (state === "pending") {
            deferred = handler;
            return;
        }
        var handlerCallback;
        if (state === "resolved") {
            handlerCallback = handler.onResolved;
        } else {
            handlerCallback = handler.onRejected;
        }
        if (!handlerCallback) {
            if (state === "resolved") {
                handler.resolve(value);
            } else {
                handler.reject(value);
            }
            return;
        }
        var ret;
        try {
            ret = handlerCallback(value);
        } catch (e) {
            handler.reject(e);
            return;
        }
        handler.resolve(ret);
    }
    fn(resolve);
}

情况基本和resolve是一样的，resolve函数中加的if判断只为了对付返回值是promise的情况下仍然可以通过后续的then方法取到值，handle中的try/catch块的加入使得可以捕获到promise及then方法回调中的错误，至于then方法的改变，看不懂的话自宫吧，你是女人当我没说。

当然这个promise只是一个基本的实现，依然很脆弱，但基本上可以说有了一轮廓，剩下的部位各位看官自己添加，比如promise的all ，race，catch等。某种意义上说，它们也只是then方法的语法糖。
http://www.mattgreer.org/arti...，本文代码出处，算是学习后的一点体会，水平有限，理解不对之处，还请指正。