手写promise

class newPromise {
    constructor(fn) {
        this.state = "pending"
        this.value = null
        this.resolveCallbacks = []
        this.rejectCallbacks = []

        this.resolve = res => {
            if (this.state === "pending") {
                setTimeout(() => {
                    this.state = "resolved"
                    this.value = res
                    this.resolveCallbacks.map(cb => cb(this.value))
                }, 0)
            }
        }
        this.reject = err => {
            if (this.state === "pending") {
                setTimeout(() => {
                    this.state = "rejected"
                    this.value = err
                    this.rejectCallbacks.map(cb => cb(this.value))
                }, 0)
            }
        }

        try {
            fn(this.resolve, this.reject)
        } catch (err) {
            this.reject(err)
        }
    }

    then(onResolve, onReject) {
        console.log("调用then")
        var promise2 = new newPromise((res, rej) => {
            if (this.state === "pending") {
                this.resolveCallbacks.push(val => {
                    try {
                        let data = onResolve(val)
                        res(data)
                    } catch (e) {
                        rej(e)
                    }
                })
                this.rejectCallbacks.push(val => {
                    try {
                        let data = onReject(val)
                        res(data)
                    } catch (e) {
                        rej(e)
                    }
                })
            }

            if (this.state === "resolved") {
                try {
                    let data = onResolve(val)
                    res(data)
                } catch (e) {
                    rej(e)
                }
            }

            if (this.state === "rejected") {
                try {
                    let data = onReject(val)
                    res(data)
                } catch (e) {
                    rej(e)
                }
            }
        })
        return promise2
    }

    resolvePromise(promise2, x, resolve, reject) {}
}

newPromise.resolve = function(x) {
    return new newPromise((res, rej) => {
        return res(x)
    })
}

newPromise.reject = function(x) {
    return new newPromise((res, rej) => {
        return rej(x)
    })
}

newPromise.all = function(arr) {
    return new newPromise((res, rej) => {
        var result = []
        var step = 0
        for (let i = 0; i < arr.length; i++) {
            arr[i].then(val => {
                result[i] = val
                step++
                if (step === arr.length) {
                    res(result)
                }
            }, rej)
        }
    })
}

newPromise.race = function(arr){
    return new newPromise((res, rej) => {
        for(let i = 0; i < arr.length; i++){
            arr[i].then(val => {
                res(val)
            }, rej)
        }
    })
}

finally

Promise.prototype.finally = function (callback) {
  let P = this.constructor;
  return this.then(
    value  => P.resolve(callback()).then(() => value),
    reason => P.resolve(callback()).then(() => { throw reason })
  );
};