promise 手动实现一部分功能

class Promise{
    constructor(executor){
        this.PromiseState = "pending";
        this.PromiseResult = null;
        this.callbacks = [];
    
        const self = this;
    
        function resolve(data){
            if(self.PromiseState !== "pending") return;
            self.PromiseState = "fulfilled";
            self.PromiseResult  = data;
            //让then方法异步执行
            setTimeout(() => {
                self.callbacks.forEach(item => {
                    item.onResolved(data);
                });
            });
            
        }
    
        function reject(data){
            if(self.PromiseState !== "pending") return;
            self.PromiseState = "rejected";
            self.PromiseResult = data;
            //让then方法异步执行
            setTimeout(() => {
                self.callbacks.forEach(item => {
                    item.onRejected(data);
                });
            });
            
        }
    
        try {
            executor(resolve, reject);
        }catch(e){
            reject(e);
        }
    }

    then(onResolved,onRejected){
        const self = this;

        //设置异常穿透
        if(typeof onRejected !== "function"){

            onRejected = reason => {
                throw reason;
            }
        }
        //设置默认值
        if(typeof onResolved !== "function"){

            onResolved = value => {
                return value;
            }
        }

        return new Promise((resolve,reject) => {

            //then返回结果，如果返回是一个promise对象就返回这个promise对象，否则直接返回一个成功的promise对象
            function callback(type){
                try{
                    let result = type(self.PromiseResult);
                    if (result instanceof Promise){
                        result.then(v =>{
                            resolve(v);
                        }, r => {
                            reject(r);
                        })
                    }else{
                        resolve(result);
                    }
                
                }catch(e){
                    reject(e);
                }
            }

            if (this.PromiseState === "fulfilled"){
                //让then方法异步执行
                setTimeout(() => {
                    callback(onResolved);
                });    
            }

            if (this.PromiseState === "rejected"){
                //让then方法异步执行
                setTimeout(() => {
                    callback(onRejected);
                });
            }

            if (this.PromiseState === "pending"){
                this.callbacks.push({
                    onResolved: function(){
                        //console.log("success");
                        callback(onResolved);
                    },
                    
                    onRejected: function(){
                        //console.log("error");
                        callback(onRejected);
                    }
                });
            }
        })
    }

    catch(onRejected){
        return this.then(undefined,onRejected);
    }

    static resolve(value){

        return new Promise((resolve, reject) => {
            if (value instanceof Promise){
                value.then(v => {
                    resolve(v);
                },r => {
                    reject(r);
                })
            }else{
                resolve(value);
            }
        })
    }

    static reject(reason){
        return new Promise ((resolve,reject) => {
            reject(reason);
        })
    }

    static all(promises){
        return new Promise ((resolve, reject) => {

            let count = 0;
            let arr = []
            for (let i = 0; i< promises.length; i++){
                promises[i].then( v => {
                    count++;
                    arr[i] = v
                    if(count === promises.length){
                        resolve(arr);
                    }
                }, r => {
                    reject(r);
                });

                if(promises[i].PromiseState === "rejected") break;
                
            }
        })
    }

    static race(promises){
        return new Promise((resolve, reject) => {
            for (let i = 0;i< promises.length;i++){
                promises[i].then(v => {
                    resolve(v);
                }, r => {
                    reject(r);
                })
    
                if(promises[i].PromiseState !== "pending") break;
            }
        })
    }

}

作为一个记录