SOURCE

//Promise/A+规范的三种状态
const PENDING = 'pending'
const FULFILLED = 'fulfilled'
const REJECTED = 'rejected'

class myPromise {
    constructor(executor) {
        this.status = PENDING
        this.data = null
        this.resolveQueue = []
        this.rejectQueue = []
        let resolve = (value) => {
            let run = () => {
                if (this.status !== PENDING) return
                this.status = FULFILLED
                this.data = null
                for (let callback of this.resolveQueue) {
                    callback(value)
                }
            }
            setTimeout(run)
        }
        let reject = (reason) => {
            let run = () => {
                if (this.status !== PENDING) return
                this.status = REJECTED
                this.data = null
                for (let callback of this.rejectQueue) {
                    callback(reason)
                }
            }
            setTimeout(run)
        }
        executor(resolve, reject)
    }
    then(resolveFn, rejectFn) {
        return new myPromise((resolve, reject) => {
            let fulfilledfn = value => {
                try {
                    resolve(resolveFn(value))
                }
                catch (error) {
                    reject(error)
                }
            }
            let rejectedFn = error => {
                try {
                    resolve(rejectFn(error))
                } catch (error) {
                    reject(error)
                }
            }
            switch (this.status) {
                case PENDING:
                    this.resolveQueue.push(fulfilledfn);
                    this.rejectQueue.push(rejectedFn)
                    break
                case FULFILLED:
                    fulfilledfn(this.data)
                    break
                case REJECTED:
                    rejectFn(this.data)
                    break
            }
        })
    }
    catch(rejectFn) {
        return this.then(null, rejectFn)
    }
    finally(callback) {
        return this.then(
            (res) => {
                callback()
                return res
            },
            (res) => {
                callback()
                throw res
            }
        )
    }
    resolve(value) {
        return new Promise(resolve => resolve(value))
    }
    reject(value) {
        return new Promise((reject, reject) => { this.reject(value) })
    }
    all(promiseList) {
        let list = []
        return new Promise((resolve, reject) => {
            promiseList.forEach((p, i) => {
                resolve(p).then(
                    val => {
                        list.push(val)
                        if (i === promiseList.length) {
                            resolve(result)
                        }
                    },
                    err => {
                        reject(err)
                    }
                )
            })

        })
    }
    race(promiseArr) {
        return new myPromise((resolve, reject) => {
            for (let p of promiseArr) {
                resolve(p).then(
                    value => {
                        resolve(value)
                    },
                    err => {
                        reject(err)
                    }
                )
            }
        })
    }
}


new myPromise(function (resolve, reject) {
    setTimeout(() => {
        console.log('test')
        resolve(2)
    }, 1000)
    resolve(2)
}).then((res) => {
    console.log(`res1${res}`)
    return 3
}).then(res => {
    console.log(`res2${res}`)
    return 4
}).then(res => {
    console.log(`res3${res}`)
    return 5
}).finally(() => {
    console.log('test')
}).then(res => {
    console.log(res)
})

<div>
    test
</div>