使用ES6实现promise

前言

在此抛砖引玉,欢迎各位指正
声明一个类
    class MyPromise{
        static PENDING = 'PENDING';
        static FULFILLED = 'FULFILLED';
        static REJECTED = 'REJECTED';

        constructor(executor) {
            this.status = MyPromise.PENDING;
            this.value = null;
            this.reason = null;
            this.cbs = [];

            try{
                executor(this.resolve.bind(this), this.reject.bind(this));
            } catch(error) {
                this.reject(error)
            }
        }

        // resolve
        resolve(value) {
            if(this.status === MyPromise.PENDING){
                this.status = MyPromise.FULFILLED;
                this.value = value;
                setTimeout(()=>{
                    this.cbs.map( callbacks =>{
                        callbacks.onFulfilled(value);
                    } )
                })

            }

        }

        //reject @reason
        reject(reason) {
            if(this.status === MyPromise.PENDING){
                this.status = MyPromise.REJECTED;
                this.reason = reason;

                setTimeout(()=>{
                    this.cbs.map( callbacks =>{
                        callbacks.onRejected(reason);
                    } )
                })
            }

        }

        /*
        *@onFulfilled 必须为function,对resolve处理的返回
        *@onRejected 必须为function,对reject处理的返回
        */
        then(onFulfilled, onRejected) {
            //没传时自动传
            if(typeof(onFulfilled) !== 'function') {
                onFulfilled = () => this.value;
            }
            if(typeof(onRejected) !== 'function') {
                onRejected = () => this.reason;
            }

            let MyPromisemise = new MyPromise((resolve, reject)=>{

                //pending时的处理
                if(this.status === MyPromise.PENDING) {
                    this.cbs.push({
                        onFulfilled: value => {
                            this.parse(MyPromisemise, onFulfilled(value), resolve, reject)
                        },
                        onRejected: value => {
                            this.parse(MyPromisemise, onRejected(value), resolve, reject)
                        }
                    })
                }

                // resolve时的处理
                if(this.status === MyPromise.FULFILLED) {
                    setTimeout(
                        ()=> {
                            this.parse(MyPromisemise, onFulfilled(this.value), resolve, reject)
                        }
                    )
                }

                // reject时的处理
                if(this.status === MyPromise.REJECTED) {
                    setTimeout(
                        ()=> {
                            this.parse(MyPromisemise, onRejected(this.reason), resolve, reject)
                        }
                    )
                }

            })
            return MyPromisemise;
        }

        //公共部分提取
        /*
        *@MyPromisemise then方法的返回值(新的MyPromisemise)
        *@result onFulfilled/onRejected
        */
        parse(MyPromisemise, result, resolve, reject){

            //如果then方法的返回值与表达式相等,这是不被允许的
            if(MyPromisemise == result) {
                throw new TypeError('chaining cycle detected');
            }

            try {
                if( result instanceof MyPromise ) {
                    result.then(resolve, reject)
                }else{
                    resolve(result);
                }
            } catch (error) {
                reject(error)
            }
        }

        //all方法  @MyPromisemises 接收的参数,是MyPromisemise的数组
        static all(MyPromisemises) {
            const values = []; //resolve的结果集
            return new MyPromise((resolve, reject)=> {
                MyPromisemises.forEach(MyPromisemise => {
                    MyPromisemise.then(
                        res => {
                            values.push(res); //将resolve的结果保存
                            if(values.length == MyPromisemises.length) {
                                resolve(values); //将所有resolve的结果返回
                            }
                        },
                        err => {
                            err => {
                                reject(err); //输出reject的原因
                            }
                        }
                    )
                })
            })
        }

        //race方法  @MyPromisemises 接收的参数,是MyPromisemise的数组
        static race(MyPromisemises) {
            return new MyPromise((resolve, reject)=> {
                MyPromisemises.forEach(MyPromisemise => {
                    MyPromisemise.then(
                        res => {
                            resolve(res)
                        },
                        err => {
                            reject(err)
                        }
                    )
                });
            })
        }

        //resolve静态方法
        static resolve(value) {
            return new MyPromise((resolve, reject)=> {
                // 判断参数是否为 MyPromisemise对象
                if(value instanceof MyPromise){
                    value.then(resolve, reject)
                }else {
                    resolve(value);
                }
            })
        }

        //reject静态方法
        static reject(value) {
            return new MyPromise((resolve, reject)=> {
                reject(value)
            })
        }
    }

评论

暂无评论