手写Promise实现

function Promise(executor) {
    this.PromiseState = "pending"
    this.PromiseResult = null
    this.callbacks = []
    const self = this
    // resolve函数
    function resolve(data) {
        // 状态值只能修改一次
        if (self.PromiseState !== "pending") return
        // 修改primise状态
        self.PromiseState = "fulfilled"
        //设置对象结果值
        self.PromiseResult = data
        setTimeout(() => {
            self.callbacks.forEach(item => {
                item.onResolved(data)
            })
        })
    }
    // reject函数
    function reject(data) {
        if (self.PromiseState !== "pending") return
        // 修改primise状态
        self.PromiseState = "rejected"
        //设置对象结果值
        self.PromiseResult = data
        setTimeout(() => {
            self.callbacks.forEach(item => {
                item.onRejected(data)
            })
        })
    }
    // 同步调用执行器函数
    try {
        executor(resolve, reject)
    } catch (error) {
        reject(error)
    }
}
Promise.prototype.then = function (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) => {
        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 (error) {
                reject(error)
            }
        }
        if (this.PromiseState === "fulfilled") {
            setTimeout(() => {
                callback(onResolved)
            })
            //callback(onResolved)
        }
        if (this.PromiseState === "rejected") {
            setTimeout(() => {
                callback(onRejected)
            })

        }
        if (this.PromiseState === "pending") {
            //保存回调函数
            this.callbacks.push({
                onResolved: function () {
                    callback(onResolved)
                },
                onRejected: function () {
                    callback(onRejected)
                },
            })
        }
    })
}
Promise.prototype.catch = function (onRejected) {
    return this.then(undefined, onRejected)
}
Promise.resolve = function (value) {
    return new Promise((resolve, reject) => {
        if (value instanceof Promise) {
            value.then(v => {
                resolve(v)
            }, r => {
                reject(r)
            })
        } else {
            resolve(value)
        }
    })
}
Promise.reject = function (reason) {
    return new Promise((_, reject) => {
        reject(reason)
    })
}
Promise.all = function (promises) {
    return new Promise((resolve, reject) => {
        let conut = 0
        let arr = []
        for (let i = 0; i < promises.length; i++) {
            promises[i].then(v => {
                conut++
                arr[i] = v;
                if (conut === promises.length) {
                    resolve(arr)
                }
            }, r => {
                reject(r)
            })
        }
    })
}
Promise.race = function (promises) {
    return new Promise((resolve, reject) => {
        for (let i = 0; i < promises.length; i++) {
            promises[i].then(v => {
                resolve(v)
            }, r => {
                reject(r)
            })
        }
    })
}