手写实现Promise的全部功能

发现的问题

在此过程中，发现 自己对 函数中的this指向，和词法环境 的一些细节没有掌握好，实现过程很痛苦！

解决

应该恶补

 

下面上代码

 

function Promise(executor){
    this.PromiseState = 'pending';
    this.PromiseResult = undefined;
    this.resolvers = [];

    var self = this;
    function resolve(data){
        if(self.PromiseState == 'pending'){
            self.PromiseState = 'fulfilled';
            self.PromiseResult = data;
            
            if(typeof self.resolvers !== 'undefined'){
                self.resolvers.forEach(element => {
                    element.onResolve();
                });
            }
        }   
    }

    function reject(data){
        console.log("执行到我了");
        if(self.PromiseState == 'pending'){
            console.log('执行到我了');
            self.PromiseState = 'rejected';
            self.PromiseResult = data;

            if(typeof self.resolvers !== 'undefined'){
                self.resolvers.forEach(element => {
                element.onReject();
                });
            }   
        }
        
    }
    executor(resolve,reject);
}
Promise.prototype.then = function(onResolve,onReject){
    if(typeof onReject !== 'function'){
        onReject:reason => {throw reason}
    }
    if(typeof onResolve !== 'function'){
        onResolve:value =>{return value}
    }
    var self = this;
   
    return new Promise((resolve,reject)=>{
        var callback = function(type){
            try{
                var result = type(self.PromiseResult);
            }catch(e){
                reject(e);
            }
            if(result instanceof Promise){
                result.then(data => {
                    resolve(data);
                },reason => {
                    reject(reason);
                })
            }else{
                resolve(result);
            }
        }
        if(this.PromiseState == 'fulfilled'){
            callback(onResolve);
        }
        if(this.PromiseState == 'rejected'){
            callback(onReject);
        }
        if(this.PromiseState = 'pending'){
            this.resolvers.push(
                {
                    onResolve:function (){
                        callback(onResolve);
                    }
                    ,
                    onReject:function (){
                        callback(onReject);
                    }
                }
            );
        }
    });
    
}

Promise.prototype.catch = function(onReject){
    return this.then(undefined,onReject);
}

Promise.resolve = function(value){
    return new Promise((resolve,rejected)=>{
        resolve(value);
    });
}

Promise.reject = function(reason){
    return new Promise((resolve,rejected)=>{
        rejected(reason);
    });
}

Promise.all =function(pArr){
    let count = 0;
    let arr = [];
    return new Promise((resolve,reject)=>{
        var length = pArr.length;
        for(var i = 0;i<length;i++){
            console.log('_________');

            pArr[i].then(
                value=>{
                    console.log("resolve");
                    count++;
                    arr[i] = (value);
                    // console.log(i);
                    console.log('22222');
                    if(count == length){
                        console.log('111112312313')
                        resolve(arr);
                    }
                },
                reason=>{
                    reject(reason);
            });
        }
        // pArr.forEach(function (item,index){
        //     console.log(item);
        //     console.log('__________');
        //     item.then(value => {
        //         arr.push(value);
        //         if(++count == pArr.length){
        //             resolve(arr);
        //             console.log('2');
        //         }
        //         console.log('1');
        //     },reason =>{
        //         console.log('3');
        //         reject(reason);
        //     });
        // });
    });
}

Promise.race = function(pArr){
    return new Promise((resolve,reject)=>{
        pArr.forEach((item,index)=>{
            item.then(v =>{
                resolve(v);
            },r=>{
                reject(r)
            });
        })
    })
}