Promise API

promise.all

romise.all()接收一个Promise[], 返回一个Promise实例
● 当 Promise[] 中所有的Promise执行完毕且都是fullfilled状态时，该实例的状态才会变成fullfilled
● 只要队列中有一个实例的状态是rejected,那么最终返回的实例状态也是reject

function _all(promises) {
    let result = []
    return new Promise((resolve,reject) => {
        if(promises.length === 0){
            resolve(result)
            return
        }
        for(let i=0;i<promises.length;i++){
            Promise.resolve(promises[i]).then((res)=>{
                result.push(res)
                if(result.length === promises.length){
                    resolve(result)
                }
            },(err) => {
                reject(err)
                return
            })
        }
    })
}

promise.allSettled

返回Promise实例，在所有Promise实例执行完毕后，状态变为fullfilled, 只会是fullfilled
无论队列中的Promise实例的状态如何，都能获取到结果

function _allSettled(promises){
    return new Promise((resolve,reject) => {
        let result = []
        if(promises.length === 0){
            resolve(result)
            return
        }
        for(let i=0;i<promises.length;i++){
            Promise.resolve(promises[i]).then((res) => {
                result.push({
                    status:'fulfilled',
                    value:res
                })
                if(result.length === promises.length){
                    resolve(result)
                }
            },(err) => {
                result.push({
                    status:'rejected',
                    reason:err
                })
                if(result.length === promises.length){
                    resolve(result)
                }
            })
        }
    })
}

promise.race

Promise.race()参数为Promise[]， 返回一个Promise实例
对Promise[]任务完成情况进行监听，如果某一个任务最先完成fullfilled/rejected,那么返回的实例的状态也会变成对应的fullfille/rejected,同时获取到最先完成的结果

function _race(promises){
    return new Promise((resolve,reject)=>{
        if(promises.length === 0){
            return
        }
        for(let i=0;i<promises.length;i++){
            Promise.resolve(promises[i]).then(
                res => {
                    resolve(res)
                    return
                },
                err => {
                    reject(err)
                    return
                }
            )
        }
    })
}

promise.any

any方法会等待一个fullfilled状态，才会决定返回Promise实例的状态
如果队列中所有的实例都是rejected， 那么也需要等所有执行完毕后才会决定返回的Promise实例状态

function _any(promises){
    let errs = []
    return new Promise((resolve,reject)=>{
        for(let i=0;i<promises.length;i++){
            Promise.resolve(promises[i]).then((res)=>{
                resolve(res)
                return
            },(err)=>{
                errs.push(err)
                if(errs.length === promises.length){
                    reject(errs)
                }
            })
        }
    })
}