异步Promise

(function(w){
            function Promise(fn){
                return this instanceof Promise ? this.init(fn) : new Promise(fn);
            }
            Promise.fulfill = function(m){return m;};
            Promise.reject = function(m){throw m;};
            Promise.map = {
                resolve: "onFulfill",
                reject: "onReject"
            }
            //异步自动生成promise并执行
            Promise.resolve = function(fn){
                var p = new Promise();
                setTimeout(function(){
                    p.resolve();
                },0);
                if(fn)
                    p.callback["onFulfill"] = fn;
                return p;
            }
            Promise.prototype = {
                init: function(fn){
                    var that = this;
                    this.state = ‘pending‘;
                    this.callback = {
                        onFulfill: Promise.fulfill,
                        onReject: Promise.reject
                    };
                    this.dirty = false;
                    this._next = null;
                    setTimeout(function(){
                        fn && fn.call(that,that.resolve,that.reject);
                    },0)

                },
                then: function(onFulfill,onReject){
                    return post.call(this,onFulfill,onReject);
                },
                wait: function(mills){ //promise链在wait处被分裂成2段
                    var p = new Promise(),
                            start = new Date().getTime();
                    var id = setTimeout(function(){ //传入时间
                        p.resolve([this.val,new Date().getTime() - start])
                    },mills);
                    p.cancel = function(){
                        clearTimeout(id);
                    }
                    return p;
                },
                all: function(){
                    var p = new Promise(),
                            args;
                    var counter = 0,ret = [];//收集结果，并传给p
                    var v,fn; //传入的函数，执行该函数，将结果保存至ret
                    if(arguments.length > 1){
                        args = [].slice.apply(arguments)
                    }else if({}.toString.call(arguments[0]) == "[object Array]"){
                        args = arguments[0];
                    }
                    for(var i=0,len=args.length;i<len;i++){
                        if(typeof args[i] == "function"){
                            args[i] = Promise.resolve(args[i]);
                        }

                        fn = args[i].callback.onFulfill;
                        v = fn.call(args[i]);
                        (function(v){
                            args[i].then(function(){
                                ret.push(v);

                                if(--counter <= 0){
                                    ret.length = len;
                                    p.resolve(ret);
                                }
                            },function(){
                                p.reject();
                            });

                        })(v)
                        counter++;
                    }
                    return p;
                }
            }
            function post(onFulfill,onReject,onNotify,onComplete){
                var p = new Promise(),
                        that = this;
                if(arguments.length <= 2){
                    that._next = p;
                    that.callback["onFulfill"] = onFulfill;
                    that.callback["onReject"] = onReject;
                    this.dirty = true;
                }
                return p;
            }
            function fire(promise,method){
                var next = "resolve",val,
                        args = arguments[2];
                if(promise.state == "pending"){
                    try{
                        this.val = val = promise.callback[Promise.map[method]].apply(promise,args);
                        promise.state = method;
                    }catch(e){
                        this.val = val = e;
                        next = "reject";
                    }

                    if(val && isPromise(val)){
                        val._next = promise._next;
                    }else{
                        if(promise._next){
                            fire(promise._next,next,[val]);
                        }
                    }

                }
                return promise;
            }
            function isPromise(o){
                return o && typeof o == "object" && o.then && typeof o.then == "function";
            }
            "reject,resolve".replace(/\w+/g,function(m){
                Promise.prototype[m] = function(){
                    return fire(this,m,arguments);
                }
            })

            w.Promise = Promise;
        })(window)
        function f1(i){console.log("f1",i);return "f1 generate"}
        function f2(i){console.log("f2",i);return "f2 generate"}
        function f2e(i){console.log("err:",i)}
        function f3(){setTimeout(function(){console.log(‘f3‘)},2000);return ‘f3‘}
        new Promise(function(){
        //    console.log(this)
            this.resolve("start:")
        }).all(f1,f3).then(f2)