手写Promise

// ES6 ES2015
// https://promisesaplus.com

const PROMISE_STATUS_PENDING = 'pending'
const PROMISE_STATUS_FULFILLED = 'fulfilled'
const PROMISE_STATUS_REJECTED = 'reject'

// 工具函数
function execFunctionWithCatchError(execFn, value, resolve, reject){
    try {
        const result = execFn(value)
        resolve(result)
    } catch (err) {
        reject(err)
    }
}

class HYPromise{
    constructor(executor) {
        this.status = PROMISE_STATUS_PENDING
        this.value = undefined
        this.reason = undefined
        this.onFulfilledFns = []
        this.onRejectedFns = []

        const resolve = (value) => {
            if (this.status === PROMISE_STATUS_PENDING){
                // setTimeout(() => {
                //     this.value = value
                //     this.onFulfilled(this.value)
                // }, 0);
                // 添加微任务
                queueMicrotask(() => { //加入微任务
                    if (this.status !== PROMISE_STATUS_PENDING) return 
                    this.status = PROMISE_STATUS_FULFILLED
                    this.value = value
                    this.onFulfilledFns.forEach(fn=>{
                        fn(this.value)
                    })
                });
            }
        }

        const reject = (reason) => {
            if (this.status === PROMISE_STATUS_PENDING){
                queueMicrotask(()=>{
                    if (this.status !== PROMISE_STATUS_PENDING) return
                    this.status = PROMISE_STATUS_REJECTED
                    this.reason = reason
                    this.onRejectedFns.forEach(fn=>{
                        fn(this.reason)
                    })
                })
            }
        }

        try {
            executor(resolve,reject)
        } catch (err){
            reject(err)
        }
    }

    then(onFulfilled, onRejected) {
        const defaultOnRejected = err => {throw err }
        onRejected = onRejected || defaultOnRejected

        const defaultOnFulfilled = value => { return value}
        onFulfilled = onFulfilled || defaultOnFulfilled

        return new HYPromise((resolve,reject) => {
            // 1.如果在then 调用的时候，状态已经确定下来
            if (this.status === PROMISE_STATUS_FULFILLED && onFulfilled){
                execFunctionWithCatchError(onFulfilled, this.value, resolve, reject)
            }
            if (this.status === PROMISE_STATUS_REJECTED && onRejected){
                execFunctionWithCatchError(onRejected, this.reason, resolve, reject)
            }

            //onFulfilled, onRejected可以做一些判断 传空传其他
            // 2.将成功回调和失败的回调放到数组中
            if (this.status === PROMISE_STATUS_PENDING){
                if (onFulfilled) this.onFulfilledFns.push(() => {
                    execFunctionWithCatchError(onFulfilled, this.value, resolve, reject)
                })
                if (onRejected) this.onRejectedFns.push(() => {
                    execFunctionWithCatchError(onRejected, this.reason, resolve, reject)
                })
            }
        })
    }

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

    finally(onFinally){
        this.then(() => {
            onFinally()
        }, () => {
            onFinally()
        })
    }

    static resolve(value) {
        return new HYPromise((resolve) => resolve(value))
    }

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

    static all(promises) {
        return new HYPromise((resolve, reject)  => {
            const values = []
            promises.forEach(promise => {
                promise.then(res => {
                    values.push(res)
                    if(values.length === promise.length){
                        resolve(values)
                    }
                }, err => {
                    reject(err)
                })
            })
        })
    }

    static allSettled(promises) {
        return new HYPromise((resolve) => {
            const results = []
            promises.forEach(promise => {
                promise.then(res => {
                    results.push({ status: PROMISE_STATUS_FULFILLED, value: res})
                    if(results.length === promise.length){
                        resolve(results)
                    }
                }, err => {
                    results.push({ status: PROMISE_STATUS_REJECTED, value: err})
                    if(results.length === promise.length){
                        resolve(results)
                    }
                })
            })
        })
    }

    static race(promises) {
        return new HYPromise((resolve, reject) => {
            promises.forEach(promise => {
                // promise.then(res => {
                //     resolve(res)
                // }, err => {
                //     reject(err)
                // })
                promise.then(resolve,reject)
            })
        })
    }

    static any(promises) {
        // resolve必须等到有一个成功的结果
        // reject所有的都失败才执行reject
        const reasons = []
        return new HYPromise((resolve, reject) => {
            promises.forEach(promise => {
                promise.then(resolve, err => {
                    reasons.push(err)
                    if (reasons.length === promises.length){
                        reject(new AggregateError(reasons))
                    }
                })
            })
        })
    }
}

HYPromise.resolve('hello').then(res => {
    console.log('res:',res)
})

// const promise = new HYPromise((resolve,reject) => {
//     console.log('状态pending')
//     resolve(2222)
//     reject(1111)
// })

// promise.then(res=>{
//     console.log('res1:',res)
// }).catch(err=>{
//     console.log('err1:',err)
// })

// promise.then(res=>{
//     console.log('res2:',res)
// },err=>{
//     console.log('err2:',err)
// })

// setTimeout(() => {
//     promise.then(res=>{
//         console.log('res3:',res)
//     },err=>{
//         console.log('err3:',err)
//     })
// }, 1000);