摘要：的實(shí)現(xiàn)說明沒有執(zhí)行里的函數(shù)說明執(zhí)行了里的函數(shù)說明執(zhí)行里的函數(shù)過程中出現(xiàn)錯誤和執(zhí)行狀態(tài)時的回調(diào)函數(shù)后返回的結(jié)果都需要執(zhí)行傳進(jìn)來的對象不能等于當(dāng)前的對象回調(diào)返回的值或者的值是對象時需要等待該對象的狀態(tài)變更設(shè)置當(dāng)前狀態(tài)的狀態(tài)和值執(zhí)行回調(diào)隊(duì)列里的函

function resolve_promise_value(promise,value) {//PromiseA+的實(shí)現(xiàn)
    var then;
    /*
        ret false 說明沒有執(zhí)行promise._resolve里的函數(shù)
        ret true 說明執(zhí)行了promise._resolve里的函數(shù)
        ret error 說明執(zhí)行promise._resolve里的函數(shù)過程中出現(xiàn)錯誤
    */
    var ret = false;
    
    /*
        resolve(promise)和執(zhí)行resolve狀態(tài)時的回調(diào)函數(shù)后返回的結(jié)果都需要執(zhí)行resolve(promise,value)
    */
    if (value === promise) {//傳進(jìn)來的對象不能等于當(dāng)前的Promise對象
        promise.reject(new TypeError("TypeError"));
    } else if (value && value instanceof Promise){//回調(diào)返回的值或者resolve的值是Promise對象時需要等待該P(yáng)romise對象的狀態(tài)變更
        value.then(promise.resolve.bind(promise),promise.reject.bind(promise));
    } else if (type(value) === "Object" || type(value) === "Function") {
        try {
            then = value.then;
        } catch(getThenErr) {
            promise.reject(thenErr);
        }
        if (type(then) === "Function") {
            try {
                then.call(value,promise.resolve.bind(promise),promise.reject.bind(promise));
            } catch(callThenErr) {
                if (promise.state === "pending") {
                    promise.reject(callThenErr);
                } 
            }
        } else {
            ret = true;
            var fn;
            promise.setState("fulfilled");//設(shè)置當(dāng)前Promise狀態(tài)的狀態(tài)和值
            promise.value = value;
            var error;
            while (fn = promise._resolve.shift()) {//執(zhí)行resolve回調(diào)隊(duì)列里的函數(shù)
                try {
                    if (typeof fn == "function") {
                        var result = fn(value);
                        promise.value = result;
                    } 
                } catch (err) {
                    ret || (ret = err);//記錄第一個執(zhí)行出錯的函數(shù)的異常信息
                }
            }
        }
    }  else {
        ret = true;
        var fn;
        promise.setState("fulfilled");//設(shè)置當(dāng)前Promise狀態(tài)的狀態(tài)和值
        promise.value = value;
        var error;
        while (fn = promise._resolve.shift()) {//執(zhí)行resolve回調(diào)隊(duì)列里的函數(shù)
            try {
                if (typeof fn == "function") {
                    var result = fn(value);
                    promise.value = result;
                } 
            } catch (err) {
                (ret instanceof Error) || (ret = err);
            }
        }
    }

    if (promise.next) {
        if (ret === true) {
            resolve_promise_value(promise.next,promise.value);
        }
        else if (ret instanceof Error){
            promise.next.reject(ret);    
        }
    }
    
}

function type(arg) {//判斷對象類型函數(shù)
    return  Object.prototype.toString.call(arg).match(/ (w+)/)[1];
}

function Promise(fn,value,state) {
    if (!(this instanceof Promise)) {//防止不用new調(diào)用Promise函數(shù)
        return new Promise(fn);
    }
    this._resolve = [];//Promise對象的fulfilled時執(zhí)行的回調(diào)隊(duì)列
    this._reject = [];//Promise對象的rejected時執(zhí)行的回調(diào)隊(duì)列
    this.next = null;//執(zhí)行下一個Promise對象
    this.value = value || null;//當(dāng)前Promise對象的值
    this.state = state || "pending";//當(dāng)前Promise對象的狀態(tài)
    this.id = Promise.idFactory();
    /*
        new 的時候如果有函數(shù)，就執(zhí)行該函數(shù)，把resolve和reject函數(shù)作為參數(shù)傳進(jìn)去，并且綁定對應(yīng)的Promise對象
    */
    try {
      fn && fn(this.resolve.bind(this),this.reject.bind(this));
    } catch (e) {
      this.reject(e);
    }
}

Promise.prototype = {
    equal: function(promise) {//根據(jù)id判斷兩個Promise對象是否相等
        return promise && (type(promise.then) === "Function") && (this.id === promise.id);
    },
    resolve: function(value) {
        if(this.state !== "pending"){
            return;
        }
        setTimeout((function() {
            resolve_promise_value(this,value)
        }).bind(this),0);
        
    },
    setState: function(state) {//設(shè)置Promise對象的狀態(tài)
        this.state = state;
    },
    reject: function(value) {
        if (this.state === "pending") {
            setTimeout((function() {
                this.setState("rejected");//設(shè)置Promise對象狀態(tài)
                this.value = value;//記錄Promise對象對應(yīng)的值
                var fn;
                var error;
                if (this._reject.length === 0) {
                    if (this.next) {
                        this.next.reject(value);
                    }
                    return;
                }
                while (fn = this._reject.shift()) {//執(zhí)行reject回調(diào)函數(shù)
                    try {
                        if (typeof fn == "function") {//對于回調(diào)函數(shù)隊(duì)列，只需記錄最后一個函數(shù)的執(zhí)行結(jié)果
                            var result = fn(value);
                            this.value = result;
                        } 
                    } catch (err) {//捕獲異常，保證回調(diào)隊(duì)列里的函數(shù)每一個都被執(zhí)行
                        error || (error = err);
                    }
                }
                if (this.next) {
                    if (error) {
                        this.next.reject(error);
                    } 
                    /*
                        執(zhí)行完當(dāng)前Promise對象的回調(diào)后，如果Promise鏈上有下一個Promise對象，繼續(xù)執(zhí)行，當(dāng)前的Promise對象的值傳進(jìn)去
                        如果error為true則說明上面代碼執(zhí)行中有異常，把異常對象傳給下一個Promise對象
                    */
                    else {
                        resolve_promise_value(this.next,result);
                    }
                }
            }).bind(this),0)
            
        }
    },
    then: function(resolve,reject) {//增加resolve和reject回調(diào)
        if (this.state != "pending") {//如果當(dāng)前Promise對象已經(jīng)resolve或reject則根據(jù)當(dāng)前Promise對象狀態(tài)異步執(zhí)行傳進(jìn)來的resolve或reject函數(shù)
            this.state === "fulfilled" ? (resolve = resolve || function() {}) : (reject = reject || function() {});
            setTimeout(this.state === "fulfilled" ? resolve.bind(null,this.value) : reject.bind(null,this.value),0);
            return;
        }
        (type(resolve) === "Function") && this._resolve.push(resolve);//記錄resolve回調(diào)
        (type(reject) === "Function") && this._reject.push(reject);
        this.next = new Promise();//返回一個新的Promise對象
        return this.next;
    },
    catch: function(reject) {//then(undefined,callback)的語法糖
        return this.then(void 0,reject);
    }
}
Promise.all = function(promiseArr) {
    if (type(promiseArr) !== "Array") {//參數(shù)需要Promise數(shù)組
        new Error("need a Array");
    }
    var count = 0;
    var result = [];//記錄每個Promise的結(jié)果
    var ret = new Promise();//返回新的Promose對象
    for (var i = 0; i< promiseArr.length ;i++) {
        promiseArr[i].then((function(i) {//每個Promise fulfilled后記錄結(jié)果并且判斷是否全部Promise對象已經(jīng)fulfilled
            return function(value) {
                result[i] = value;
                count++;
                if (count === promiseArr.length) {//全部Promise fulfilled的話就執(zhí)行resovle
                    ret.resolve(result); 
                }
            }
        })(i),function(value) {
            if (ret.state === "pending") {//有一個Promise對象reject并且ret還是pending狀態(tài)的話就直接返回
                ret.reject(value);
            }    
        })
    }
    return ret;
}

Promise.race = function(promiseArr) {
    if (type(promiseArr) !== "Array") {
        new Error("need a Array");
    }
    var ret = new Promise();
    for (var i = 0; i< promiseArr.length ;i++) {
        promiseArr[i].then(function(value) {
            if (ret.state === "pending") {//有一個Promise對象resolve的話就返回，并且放棄其余的Promise對象的結(jié)果
                ret.resolve(value);
            }
        },function(value) {
            if (ret.state === "pending") {//有一個Promise對象reject的話就返回，并且放棄其余的Promise對象的結(jié)果
                ret.reject(value);
            }    
        });
    }
    return ret;
}

Promise.resolve = function(arg) {
    if (arg && typeof arg.then === "function") {//參數(shù)是Promise對象的話直接返回
        return arg;
    } else {//否則用參數(shù)構(gòu)造一個Promise對象
        var result = new Promise(null,arg,"fulfilled");
        //result.resolve(arg);
        return result;
    }
}

Promise.reject = function(arg) {//同resolve
    if (arg && typeof arg.then === "function") {
        return arg;
    } else {
        var result = new Promise(null,arg,"reject");
        //result.reject(arg);
        return result;
    }
}
Promise.idFactory = (function() {//id構(gòu)造工廠，id用于比較是否是同一個Promise對象
    var _id = 0;
    return function() {
        return _id += 1;
    }
})();

module.exports = Promise;