使用回调函数实现Promise

内容介绍

原版promise功能介绍和使用请点这里
目前已经实现的方法：

• myPromiseObj.then()
• myPromiseObj.catch()
• myPromiseObj.finally()
• MyPromise.resolve()
• MyPromise.reject()
• MyPromise.race()
• MyPromise.all()
• MyPromise.allSettled()

我的目的在于实现promise控制异步任务的功能，而有些不重要（我觉得）的细节可能与原版promise有所不同，比如对与下面这段代码，原生promise输出顺序是===x —x hhh 而mypromise里输出顺序是 ===x hhh --x 。

const resPromise = function(x){
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            console.log('===x')
            resolve(x)
            console.log('---x')
        }, 1000)
    })
}
resPromise('hhh').then(val => {console.log(val)})

我想原版的promise可能对状态的改变和then、catch、finally中回调函数的执行做了异步化处理，无论resolve是否同步执行，后面的then、catch、finally中的回调函数全部异步执行。而对于我写的mypromise，如果resolve是同步执行的，那么后面的then、catch、finally中的回调函数也会同步执行。

完整代码

MyPromise.js完整代码如下

function MyPromise(resolver){

    const resolved = 'resolved'
    const pending = 'pending'
    const rejected = 'rejected'
    
    let state = pending
    let resultValue
    let resolveTasks = [] //resolve时执行的任务
    let rejectTasks = []  //reject时执行的任务
    let finallyTasks = []
    
    /* 
        调用resolve可能并不会立即改变状态，
        如果value是promise类型，为了使结果值不为promise类型，它会递归得到value的最终值，然后再根据结果改变状态
        如果最终状态是resolved，那么就调用resolveTasks和finallyTasks
        如果最终状态是rejected，则调用reject 
    */
    function resolve(value){
        if(state !== pending){
            return ;
        }
        if(value instanceof MyPromise){
            value.then(
                val => {resolve(val)},
                reason => reject(reason)
            )
        }
        else {
            state = resolved
            resultValue = value
            for(let resolveTask of resolveTasks){
                resolveTask(value)
            }
            for(let finallyTask of finallyTasks){
                finallyTask()
            }
        }
    }

    //无论value是不是promise类型，立即把结果值改为value，状态值改为rejected，并运行rejectTasks里的函数
    function reject(reason){
        if(state !== pending){
            return ;
        }
        state = rejected
        resultValue = reason
        for(let rejectTask of rejectTasks){
            rejectTask(reason)
        }  
        for(let finallyTask of finallyTasks){
            finallyTask()
        }
    }

    //默认的then里面的第一个回调函数，为了实现值穿透的效果
    function defaultHandler(value){
        return value
    }

    // then返回一个promise，当两个回调函数中的某个被调用时，设返回值为retValue，则在该promise内部会执行resolve(retValue)
    this.then = function(resolveFunction, rejectFunction){
        
        //为了实现值穿透，then中的第一个回调函数为空时，将其赋为此默认值
        resolveFunction = resolveFunction || defaultHandler


        //立即调用then的第一个回调函数，如果没有，则使用默认函数代替，以实现值穿透的效果
        if(state === resolved){
            return new MyPromise((resolve, reject) => {
                resolve(resolveFunction(resultValue))
            })
        }
        //立即调用then的第二个回调函数
        else if(state === rejected){
            return new MyPromise((resolve, reject) => {
                if(rejectFunction instanceof Function){
                    resolve(rejectFunction(resultValue))
                }
                else{
                    //如果缺少错误处理函数，那么直接调用reject
                    //使then()的返回值为 状态=rejected resultValue=本对象结果值 的promise对象，以实现错误穿透效果。
                    reject(resultValue)
                }
            })
        }
        else{
            return new MyPromise((resolve, reject) => {
                function resolveTask(value){
                    resolve(resolveFunction(value))
                }
                function rejectTask(reason){
                    if(rejectFunction instanceof Function){
                        resolve(rejectFunction(resultValue))
                    }
                    else{
                        //原理同上
                        reject(resultValue)
                    }
                }
                resolveTasks.push(resolveTask)
                rejectTasks.push(rejectTask)
            })
        }
    }
    this.catch = function(rejectFunction){
        if(state === rejected){
            return new MyPromise((resolve, reject) => {
                if(rejectFunction instanceof Function){
                    resolve(rejectFunction(resultValue))
                }
                else{
                    //原理同上
                    reject(resultValue)
                }
            })
        }
        else{
            return new MyPromise((resolve, reject) => {
                function rejectTask(reason){
                    if(rejectFunction instanceof Function){
                        resolve(rejectFunction(resultValue))
                    }
                    else{
                        //原理同上
                        reject(resultValue)
                    }
                }
                rejectTasks.push(rejectTask)
            })
            
        }
    }
    this.finally = function(finallyFunction){
        if(!(finallyFunction instanceof Function)){
            return
        }
        if(state !== pending){
            finallyFunction()
        }
        else {
            finallyTasks.push(finallyFunction)
        }
    }
    
    if(!(resolver instanceof Function)){
        throw('param of MyPromise constructor should be a function!')
    }
    else{
       resolver(resolve, reject) 
    }
}

MyPromise.resolve = function(value){
    if(value instanceof MyPromise){
        return value
    }
    return new MyPromise((resolve, reject) => {
        resolve(value)
    })
}
MyPromise.reject = function(value){
    return new MyPromise((resolve, reject) => {
        reject(value)
    })
}

MyPromise.all = function(promises){
    return new MyPromise((resolve, reject) => {
        if(!(promises instanceof Array)){
            throw('param of MyPromis.all() show be an array!')
        }
        let ans = []
        let count = 0
        promises.forEach((promise, index) => {
            if(!(promise instanceof MyPromise)){
                promise = MyPromise.resolve(promise)
            }
            promise.then(
                value => {
                    ans[index] = value
                    count++
                    if(count === promises.length){
                        resolve(ans)
                    }
                },
                reason => {reject(reason)}
            )
        })
    })

}
MyPromise.allSettled = function(promises){
    return new MyPromise((resolve, reject) => {
        if(!(promises instanceof Array)){
            throw('param of MyPromis.allSettled() show be an array!')
        }
        let ans = []
        let count = 0
        promises.forEach((promise, index) => {
            if(!(promise instanceof MyPromise)){
                promise = MyPromise.resolve(promise)
            }
            promise.then(
                value => {
                    let result = {value, status:'fullfilled'}
                    ans[index] = result
                    count++
                    if(count === promises.length){
                        resolve(ans)
                    }
                },
                reason => {
                    let result = {reason, status:'rejected'}
                    ans[index] = result
                    count++
                    if(count === promises.length){
                        resolve(ans)
                    }
                }
            )
        })
    })
}
MyPromise.race = function(promises){
    return new MyPromise((resolve, reject) => {
        if(!(promises instanceof Array)){
            throw('param of MyPromis.race() show be an array!')
        }
        promises.forEach((promise) => {
            if(!(promise instanceof MyPromise)){
                promise = MyPromise.resolve(promise)
            }
            promise.then(
                value => {resolve(value)},
                reason => {reject(reason)}
            )
        })
    })
}
module.exports =  MyPromise