Promise.all()

多个promise，有一个err返回err，否则全部成功才返回成功数组

Promise.all = function (promises) {
    return new Promise((resolve, reject) => {
        if (!Array.isArray(promises)) {
            reject('Promise.all requires an array')
        }
        let result = []
        let resolvedNum = 0
        let len = promises.length
        let processResult = (data, index) => {
            result[index] = data
            resolvedNum++
            if (resolvedNum === len) {
                // 全部成功，统一返回
                resolve(result)
            }
        }

        for (let i = 0; i < len; i++) {
            Promise.resolve(promises[i]).then(
                result => {
                    console.log(result)
                    // 成功一个暂存一个
                    processResult(result, i)
                },
                err => {
                    // 有一个失败直接返回这个失败
                    reject(err)
                })
        }
    })
}

Promise.race()

多个promise，哪个快返回哪个

Promise.race = function (promises) {
    return new Promise((resolve, reject) => {
        if (!Array.isArray(promises)) {
            reject('Promise.race requires an array')
        }
        let len = promises.length
        for (let i = 0; i < len; i++) {
            Promise.resolve(promises[i]).then(
                result => {
                    resolve(result)
                },
                err => {
                    reject(err)
                })
        }
    })
}

Promise.allSettled()

多个promise 不论成功与否，全部塞到数组返回

Promise.allSettled = function (promises) {
    return new Promise((resolve, reject) => {
        if (!Array.isArray(promises)) {
            reject('Promise.allSettled requires an array')
        }
        let result = []
        let processNum = 0
        let len = promises.length
        let processResult = (data, index) => {
            result[index] = data
            processNum++
            if(processNum === len){
                resolve(result)
            }
        }

        for(let i = 0; i < len; i++){
            Promise.resolve(promises[i]).then(
                res => {
                    console.log(res)
                    processResult(res, i)
                },
                err => {
                    processResult(err, i)
                }
            )
        }

    })
}

Promise.any()

多个promise 有一个成功，返回成功，全部被拒绝，执行拒绝操作

Promise.any = function (promises) {
    return new Promise((resolve, reject) => {
        if (!Array.isArray(promises)) {
            reject('Promise.any requires an array')
        }
        let reasons = []
        let rejectNum = 0
        let len = promises.length
        let processReason = (data, index) => {
            reasons[index] = data
            rejectNum++
            if(rejectNum === len){
                reject(reasons)
            }
        }

        for(let i =0; i < len; i++){
            Promise.resolve(promises[i]).then(
                res => {
                    resolve(res)
                },
                err => {
                    processReason(err, i)
                }
            )
        }

    })
}