手写Promise（三）——最终版

最终版

最终版添加了catch、resolve、reject、all、race方法，最终以类的形式封装

class Promise {
    // 构造方法
    constructor(executor) {
        // 添加状态
        this.PromiseState = 'pending'
        this.PromiseResult = null;

        // 声明属性
        this.callback = [];

        // 保存实例对象的this值
        const self = this;

        // resolve 函数
        function resolve(data) {
            // 判断状态
            if (self.PromiseState !== 'pending') return;

            // 1. 修改对象的状态（实例对象上的一个属性，promiseState）
            self.PromiseState = 'fulfilled';// 和resolve一样        
            // 2. 设置对象结果值(PromiseResult)
            self.PromiseResult = data;

            // 调用成功的回调函数
            setTimeout(() => {
                self.callback.forEach(item => {
                    item.onResolved(data);
                });
            })

        }

        // reject   函数
        function reject(data) {
            // 判断状态
            if (self.PromiseState !== 'pending') return;
            // 1. 修改对象的状态（实例对象上的一个属性，promiseState）
            self.PromiseState = 'rejected';// 和resolve一样
            // 2. 设置对象结果值(PromiseResult)
            self.PromiseResult = data;
            setTimeout(() => {
                // 调用失败的回调函数
                self.callback.forEach(item => {
                    item.onRejected(data);
                });
            })

        }

        try {
            // 同步调用 【执行器函数】
            executor(resolve, reject);
        } catch (e) {
            // 修改promise 对象状态为 [失败]
            reject(e);
        }
    }

    // then方法的封装
    then(onResolved,onRejected){
        const self = this;
        if (typeof onRejected !== 'function') {
            onRejected = reason => {
                throw reason;
            }
        }
        if (typeof onResolved !== 'function') {
            onResolved = value => value;
        }
    
        return new Promise((resolve, reject) => {
            // 封装函数 callback
            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)
                }
            }
    
    
            // 调用回调函数,根据PromiseState判断
            if (this.PromiseState === 'fulfilled') {
                setTimeout(() => {
                    callback(onResolved)
                })
    
            }
            if (this.PromiseState === 'rejected') {
                setTimeout(() => {
                    callback(onRejected);
                })
    
            }
    
            // 判断pending状态
            if (this.PromiseState === 'pending') {
    
                setTimeout(() => {
                    // 保存回调函数
                    this.callback.push({
                        onResolved: function () {
                            callback(onResolved);
    
                        },
                        onRejected: function () {
                            callback(onRejected);
    
                        }
                    })
                })
    
            }
        })
    
    
    }

    // catch方法
    catch(onRejected){
    return this.then(undefined, onRejected)

    }

    // 添加resolve,它不属于实例对象，它属于类
    static resolve(value){
         // 返回对象是一个Promise对象
    return new Promise((resolve, reject) => {
        if (value instanceof Promise) {
            value.then(v => {
                resolve(v);
            }, r => {
                reject(r);
            })
        } else {
            // 只要不是Promise 状态就是成功
            resolve(value);
        }
    })
    }

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

    // 添加all方法
    static all(promises){
         // 返回的结果是一个promise的对象
    return new Promise((resolve, reject) => {
        // 声明变量
        let count = 0;
        let arr = [];
        // 遍历
        for (let i = 0; i < promises.length; i++) {
            //
            promises[i].then(v => {
                // 得知对象的状态是成功
                // 每个promise对象都成功才能去执行resolve
                count++;
                // 将当前promise对象成功存入到数组中
                arr[i] = v;

                // 判断
                if (count === promises.length) {
                    // 修改状态
                    resolve(arr)
                }
            }, r => {
                reject(r);
            })
        }
    })
    }

    // 添加race方法
    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);
                })
            }
        })
    }
}