Promise方法手写大法

Promise.resolve()

将现有对象转为 Promise 对象

Promise.resolve('foo')
// 等价于
new Promise(resolve => resolve('foo'))

  Promise.resolve = function (res) {
          return new Promise((res) => {
              resolve(res)
          })
      }

Promise.prototype.catch

  Promise.prototype.catch = function (fn) {
          return this.then(null, fn)
      }

Promise.prototype.finally

finally()方法用于指定不管 Promise 对象最后状态如何，都会执行的操作。

且不能传递参数，所以无法获取这个实例的状态。但还要返回这个状态结果。

 Promise.prototype.finally=function(onFinished){
 		return this.then((result)=>{
            onFinished()
            return result
        }).catch((e)=>{
 			onFinished()
            return e
        })
 }

Promise.all()

返回Promise实例，接收参数为一个数组，当有不是Promise的实例的时候，会调用Promise.resolve方法转化。

返回第一个被reject的实例给回调函数

Promise.all = function (promises) {
        let results  = []
        let promiseCount = 0;
        let promisesLength = promises.length;
        return new Promise((resolve, reject) => {
            for (let val of promises) {
                Promise.resolve(val).then(function (res) {

                    results[promiseCount] = res;
                    promiseCount++;
                    // 当所有函数都正确执行了，resolve输出所有返回结果。
                    if (promiseCount === promisesLength) {
                        return resolve(results);
                    }

                }, function (err) {
                    return reject(err);
                });
            }
        })
    }

Promise.any

  //Promise.any 和all相反 所有都rejected时候返回 AggregateError: All promises were rejected
    Promise.any=function(promises){
        let errorcount=0
        let promiselength=promises.length

        return new Promise((resolve,reject)=>{
            for(let val of promises){
                Promise.resolve(val).then(function(res){
                        return resolve(res)
                },function(e){
                    errorcount++
                    //所有都reject的话 返回这个错误
                    if(errorcount===promiselength)
                    {  
                        return reject(new AggregateError('All promises were rejected'))
                    }
                   
                })
            }
        })
    }

Promise.race

传入一个数组。竞争关系，返回第一个完成的实例。

    //promise.race
    Promise.race=function(promises){

        return new Promise ((resolv,reject)=>{
            for(let val of promises){
                return Promise.resolve(val).then(function(res){
                        return resolv(res)
                },function(e){
                        return reject(e)
                })
            }
        })
    }

Promise.allSettled

Promise.allSettled=function(promises){
        let allresult=[]
        let count=0
        let promiselength=promises.length

        return new Promise((resolve,reject)=>{
                for(let val of promises){
                    Promise.resolve(val).then(function(res){
                        allresult[count]={state:'fulfilled', value:res};
                        count++
                    },function(e){
                        allresult[count]={state:'rejected', value:e};
                        count++
                    }).finally(()=>{
                        if(promiselength==count)
                        resolve(allresult);
                    })
                }
        })
    }