关于javascript:实现Promise的原型方法前端面试能力提升

说起 Promise 大家应该都耳熟能详，咱们明天来看下 Promise 的相干办法

有如下：
原型办法：then、catch、finally

静态方法：resolve、reject、race、all、allSettled、any

手写实现办法如下：

实现 resolve 办法

promise.resolve('123')本质上就是
new Promise(resolve=>
resolve('123')
})

Promise.resolve(value) 将给定的一个值转为 Promise 对象。

• 如果这个值是一个 promise，那么将返回这个 promise；
• 如果这个值是 thenable（即带有 ”then” 办法），返回的 promise 会“追随”这个 thenable 的对象，采纳它的最终状态；
• 否则返回的 promise 将以此值实现，即以此值执行 resolve()办法 (状态为 fulfilled)。

 class MyPromise {
        static PENDING = 'pending'
        static FULFILLED = 'fulfilled'
        static REJECTED = 'rejected'
        constructor(executor) {
          this.PromiseState = MyPromise.PENDING
          this.PromiseResult = null
          this.fulfilledCallBacks = []
          this.rejectedCallBacks = []
          try {executor(this.resolve.bind(this), this.reject.bind(this))
          } catch (error) {this.reject(error)
          }
        }
        resolve(result) {if ((this.PromiseState = MyPromise.PENDING)) {setTimeout(() => {
              this.PromiseState = MyPromise.FULFILLED
              this.PromiseResult = result
              for (const callBack of this.fulfilledCallBacks) {callBack(result)
              }
            })
          }
        }
        reject(reason) {if ((this.PromiseState = MyPromise.PENDING)) {setTimeout(() => {
              this.PromiseState = MyPromise.REJECTED
              this.PromiseResult = reason
              for (const callBack of this.rejectedCallBacks) {callBack(reason)
              }
            })
          }
        }
        then(onFulfilled, onRejected) {
          onFulfilled =
            typeof onFulfilled === 'function' ? onFulfilled : (val) => val
          onRejected =
            typeof onRejected === 'function'
              ? onRejected
              : (err) => {throw err}
          return new MyPromise((resolve, reject) => {if (this.PromiseState === MyPromise.PENDING) {this.fulfilledCallBacks.push(() => {setTimeout(() => {let x = onFulfilled(this.PromiseResult)
                  x instanceof MyPromise ? x.then(resolve, reject) : resolve(x)
                })
              })
              this.rejectedCallBacks.push(() => {setTimeout(() => {let x = onRejected(this.PromiseResult)
                  x instanceof MyPromise ? x.then(resolve, reject) : reject(x)
                })
              })
            } else if (this.PromiseState === MyPromise.FULFILLED) {
              try {setTimeout(() => {let x = onFulfilled(this.PromiseResult)
                  x instanceof MyPromise ? x.then(resolve, reject) : resolve(x)
                })
              } catch (error) {reject(error)
              }
            } else {
              try {setTimeout(() => {let x = onRejected(this.PromiseResult)
                  x instanceof MyPromise ? x.then(resolve, reject) : reject(x)
                })
              } catch (error) {reject(error)
              }
            }
          })
        }
        //value 要解析为 Promise 对象的值
        static resolve(value) {
          // 如果是
          if (value instanceof MyPromise) {return value} else if (value && typeof value === 'object' && 'then' in value) {return new MyPromise((resolve, reject) => {value.then(resolve, reject)
            })
          }
          return new MyPromise((resolve) => {resolve(value)
          })
        }
      }
      const promise1 = MyPromise.resolve(123)

      promise1.then((value) => {console.log(value)
        // expected output: 123
      })

      // Resolve 一个 thenable 对象
      var p1 = MyPromise.resolve({then: function (onFulfill) {onFulfill('Resolving')
        },
      })
      console.log(p1 instanceof MyPromise) // true, 这是一个 Promise 对象

      setTimeout(() => {console.log('p1 :>>', p1)
      }, 1000)

      p1.then(function (v) {console.log(v) // 输入 "Resolving!"
        },
        function (e) {// 不会被调用}
      )

      // Thenable 在 callback 之前抛出异样
      // MyPromise rejects
      var thenable = {then: function (resolve) {throw new TypeError('Throwing')
          resolve('Resolving')
        },
      }

      var p2 = MyPromise.resolve(thenable)
      p2.then(function (v) {// 不会被调用},
        function (e) {console.log(e) // TypeError: Throwing
        }
      )

实现 reject 办法

const p=Promise.reject(‘error’)
相当于下方函数:
const p=new Promise(reject=>{
reject(‘11111’)
})

Promise.reject()办法返回一个带有回绝起因的 Promise 对象。

参考 前端进阶面试题具体解答

 class MyPromise {
        static PENDING = 'pending'
        static FULFILLED = 'fulfilled'
        static REJECTED = 'rejected'
        constructor(executor) {
          this.PromiseState = MyPromise.PENDING
          this.PromiseResult = null
          this.fulfilledCallBacks = []
          this.rejectedCallBacks = []
          try {executor(this.resolve.bind(this), this.reject.bind(this))
          } catch (error) {this.reject(error)
          }
        }
        resolve(result) {if ((this.PromiseState = MyPromise.PENDING)) {setTimeout(() => {
              this.PromiseState = MyPromise.FULFILLED
              this.PromiseResult = result
              for (const callBack of this.fulfilledCallBacks) {callBack(result)
              }
            })
          }
        }
        reject(reason) {if ((this.PromiseState = MyPromise.PENDING)) {setTimeout(() => {
              this.PromiseState = MyPromise.REJECTED
              this.PromiseResult = reason
              for (const callBack of this.rejectedCallBacks) {callBack(reason)
              }
            })
          }
        }
        then(onFulfilled, onRejected) {
          onFulfilled =
            typeof onFulfilled === 'function' ? onFulfilled : (val) => val
          onRejected =
            typeof onRejected === 'function'
              ? onRejected
              : (err) => {throw err}
          return new MyPromise((resolve, reject) => {if (this.PromiseState === MyPromise.PENDING) {this.fulfilledCallBacks.push(() => {setTimeout(() => {let x = onFulfilled(this.PromiseResult)
                  x instanceof MyPromise ? x.then(resolve, reject) : resolve(x)
                })
              })
              this.rejectedCallBacks.push(() => {setTimeout(() => {let x = onRejected(this.PromiseResult)
                  x instanceof MyPromise ? x.then(resolve, reject) : reject(x)
                })
              })
            } else if (this.PromiseState === MyPromise.FULFILLED) {
              try {setTimeout(() => {let x = onFulfilled(this.PromiseResult)
                  x instanceof MyPromise ? x.then(resolve, reject) : resolve(x)
                })
              } catch (error) {reject(error)
              }
            } else {
              try {setTimeout(() => {let x = onRejected(this.PromiseResult)
                  x instanceof MyPromise ? x.then(resolve, reject) : reject(x)
                })
              } catch (error) {reject(error)
              }
            }
          })
        }
        //error 要解析为 Promise reject 的值
        static reject(error) {return new MyPromise((resolve, reject) => {reject(error)
          })
        }
      }
      MyPromise.reject(new Error('fail')).then(function () {// not called},
        function (error) {console.error(error) // Error: fail
        }
      )

实现 Promise.prototype.catch 办法

catch() 办法返回一个 Promise，并且解决回绝的状况，用于指定产生谬误时的回调函数。

它的行为与调用 Promise.prototype.then(undefined, onRejected) 雷同。

class MyPromise {
    static PENDING = 'pending'
    static FULFILLED = 'fulfilled'
    static REJECTED = 'rejected'
    constructor(executor) {
        this.PromiseState = MyPromise.PENDING
        this.PromiseResult = null
        this.fulfilledCallBacks = []
        this.rejectedCallBacks = []
        try {executor(this.resolve.bind(this), this.reject.bind(this))
        } catch (error) {this.reject(error)
        }
    }
    resolve(result) {if ((this.PromiseState = MyPromise.PENDING)) {setTimeout(() => {
                this.PromiseState = MyPromise.FULFILLED
                this.PromiseResult = result
                for (const callBack of this.fulfilledCallBacks) {callBack(result)
                }
            })
        }
    }
    reject(reason) {if ((this.PromiseState = MyPromise.PENDING)) {setTimeout(() => {
                this.PromiseState = MyPromise.REJECTED
                this.PromiseResult = reason
                for (const callBack of this.rejectedCallBacks) {callBack(reason)
                }
            })
        }
    }
    then(onFulfilled, onRejected) {
        onFulfilled =
            typeof onFulfilled === 'function' ? onFulfilled : (val) => val
        onRejected =
            typeof onRejected === 'function'
            ? onRejected
            : (err) => {throw err}
        return new MyPromise((resolve, reject) => {if (this.PromiseState === MyPromise.PENDING) {this.fulfilledCallBacks.push(() => {setTimeout(() => {let x = onFulfilled(this.PromiseResult)
                        x instanceof MyPromise ? x.then(resolve, reject) : resolve(x)
                    })
                })
                this.rejectedCallBacks.push(() => {setTimeout(() => {let x = onRejected(this.PromiseResult)
                        x instanceof MyPromise ? x.then(resolve, reject) : reject(x)
                    })
                })
            } else if (this.PromiseState === MyPromise.FULFILLED) {
                try {setTimeout(() => {let x = onFulfilled(this.PromiseResult)
                        x instanceof MyPromise ? x.then(resolve, reject) : resolve(x)
                    })
                } catch (error) {reject(error)
                }
            } else {
                try {setTimeout(() => {let x = onRejected(this.PromiseResult)
                        x instanceof MyPromise ? x.then(resolve, reject) : reject(x)
                    })
                } catch (error) {reject(error)
                }
            }
        })
    }
    catch(onRejected) {return this.then(undefined, onRejected)
    }
}

// 捕捉异样
const p2 = new MyPromise(function (resolve, reject) {throw new Error('test')
})
p2.catch(function (error) {console.log(error) //Error: test
})

实现 Promise.prototype.finally

finally() 办法返回一个 Promise。在 promise 完结时，无论后果是 fulfilled 或者是 rejected，都会执行指定的回调函数。

因为无奈晓得 promise 的最终状态，所以 finally 的回调函数中不接管任何参数，它仅用于无论最终后果如何都要执行的状况。

   class MyPromise {
        static PENDING = 'pending'
        static FULFILLED = 'fulfilled'
        static REJECTED = 'rejected'
        constructor(executor) {
          this.PromiseState = MyPromise.PENDING
          this.PromiseResult = null
          this.fulfilledCallBacks = []
          this.rejectedCallBacks = []
          try {executor(this.resolve.bind(this), this.reject.bind(this))
          } catch (error) {this.reject(error)
          }
        }
        resolve(result) {if ((this.PromiseState = MyPromise.PENDING)) {setTimeout(() => {
              this.PromiseState = MyPromise.FULFILLED
              this.PromiseResult = result
              for (const callBack of this.fulfilledCallBacks) {callBack(result)
              }
            })
          }
        }
        reject(reason) {if ((this.PromiseState = MyPromise.PENDING)) {setTimeout(() => {
              this.PromiseState = MyPromise.REJECTED
              this.PromiseResult = reason
              for (const callBack of this.rejectedCallBacks) {callBack(reason)
              }
            })
          }
        }
        then(onFulfilled, onRejected) {
          onFulfilled =
            typeof onFulfilled === 'function' ? onFulfilled : (val) => val
          onRejected =
            typeof onRejected === 'function'
              ? onRejected
              : (err) => {throw err}
          return new MyPromise((resolve, reject) => {if (this.PromiseState === MyPromise.PENDING) {this.fulfilledCallBacks.push(() => {setTimeout(() => {let x = onFulfilled(this.PromiseResult)
                  x instanceof MyPromise ? x.then(resolve, reject) : resolve(x)
                })
              })
              this.rejectedCallBacks.push(() => {setTimeout(() => {let x = onRejected(this.PromiseResult)
                  x instanceof MyPromise ? x.then(resolve, reject) : reject(x)
                })
              })
            } else if (this.PromiseState === MyPromise.FULFILLED) {
              try {setTimeout(() => {let x = onFulfilled(this.PromiseResult)
                  x instanceof MyPromise ? x.then(resolve, reject) : resolve(x)
                })
              } catch (error) {reject(error)
              }
            } else {
              try {setTimeout(() => {let x = onRejected(this.PromiseResult)
                  x instanceof MyPromise ? x.then(resolve, reject) : reject(x)
                })
              } catch (error) {reject(error)
              }
            }
          })
        }
        finally(callBack) {return this.then(callBack, callBack)
        }
      }

      // 捕捉异样
      let p1 = new MyPromise(function (resolve, reject) {resolve(1)
      }).finally(function () {console.log('finally') // finally
        })

实现 Promise.all

Promise.all() 办法接管一个 promise 的 iterable 类型（注：Array，Map，Set 都属于 ES6 的 iterable 类型）的输出，并且只返回一个 Promise 实例，输出的所有 promise 的 resolve 回调的后果是一个数组。

• Promise.all 期待所有都实现（或第一个失败）
• 如果传入的参数是一个空的可迭代对象，则返回一个已实现（already resolved）状态的 Promise
• 如果参数中蕴含非 promise 值，这些值将被疏忽，但依然会被放在返回数组中，如果 promise 实现的话 (也就是如果参数里的某值不是 Promise，则须要原样返回在数组里)
• 在任何状况下，Promise.all 返回的 promise 的实现状态的后果都是一个数组，它蕴含所有的传入迭代参数对象的值（也包含非 promise 值）。
• 如果传入的 promise 中有一个失败（rejected），Promise.all 异步地将失败的那个后果给失败状态的回调函数，而不论其它 promise 是否实现

class MyPromise {
  static PENDING = 'pending'
  static FULFILLED = 'fulfilled'
  static REJECTED = 'rejected'
  constructor(executor) {
    this.PromiseState = MyPromise.PENDING
    this.PromiseResult = null
    this.fulfilledCallBacks = []
    this.rejectedCallBacks = []
    try {executor(this.resolve.bind(this), this.reject.bind(this))
    } catch (error) {this.reject(error)
    }
  }
  resolve(result) {if ((this.PromiseState = MyPromise.PENDING)) {setTimeout(() => {
        this.PromiseState = MyPromise.FULFILLED
        this.PromiseResult = result
        for (const callBack of this.fulfilledCallBacks) {callBack(result)
        }
      })
    }
  }
  reject(reason) {if ((this.PromiseState = MyPromise.PENDING)) {setTimeout(() => {
        this.PromiseState = MyPromise.REJECTED
        this.PromiseResult = reason
        for (const callBack of this.rejectedCallBacks) {callBack(reason)
        }
      })
    }
  }
  then(onFulfilled, onRejected) {
    onFulfilled =
      typeof onFulfilled === 'function' ? onFulfilled : (val) => val
    onRejected =
      typeof onRejected === 'function'
      ? onRejected
      : (err) => {throw err}
    return new MyPromise((resolve, reject) => {if (this.PromiseState === MyPromise.PENDING) {this.fulfilledCallBacks.push(() => {setTimeout(() => {let x = onFulfilled(this.PromiseResult)
            x instanceof MyPromise ? x.then(resolve, reject) : resolve(x)
          })
        })
        this.rejectedCallBacks.push(() => {setTimeout(() => {let x = onRejected(this.PromiseResult)
            x instanceof MyPromise ? x.then(resolve, reject) : reject(x)
          })
        })
      } else if (this.PromiseState === MyPromise.FULFILLED) {
        try {setTimeout(() => {let x = onFulfilled(this.PromiseResult)
            x instanceof MyPromise ? x.then(resolve, reject) : resolve(x)
          })
        } catch (error) {reject(error)
        }
      } else {
        try {setTimeout(() => {let x = onRejected(this.PromiseResult)
            x instanceof MyPromise ? x.then(resolve, reject) : reject(x)
          })
        } catch (error) {reject(error)
        }
      }
    })
  }

  //value 要解析为 Promise 对象的值
  static resolve(value) {
    // 如果是
    if (value instanceof MyPromise) {return value} else if (value && typeof value === 'object' && 'then' in value) {return new MyPromise((resolve, reject) => {value.then(resolve, reject)
      })
    }
    return new MyPromise((resolve) => {resolve(value)
    })
  }
  static all(promiseList) {if (Array.isArray(promiseList)) {return new MyPromise((resolve, reject) => {if (promiseList.length === 0) {resolve(promiseList)
        }
        let count = 0
        let result = []
        promiseList.forEach((item, index) => {if (item instanceof MyPromise) {MyPromise.resolve(item).then((res) => {
                count++
                result[index] = res
                count === promiseList.length && resolve(result)
              },
              (error) => {reject(error)
              }
            )
          } else {
            count++
            result[index] = item
            count === promiseList.length && resolve(result)
          }
        })
      })
    } else {throw TypeError('argument must be Array')
    }
  }
}

// 捕捉异样

const promise1 = MyPromise.resolve(3)
const promise2 = 42
const promise3 = new MyPromise((resolve, reject) => {setTimeout(() => {resolve(100)
  })
})

MyPromise.all([promise1, promise2, promise3]).then((values) => {console.log(values)
})
// [3, 42, 100]

实现 Promise.allSettled

Promise.allSettled(iterable)办法返回一个在所有给定的 promise 都曾经 fulfilled 或 rejected 后的 promise，并带有一个对象数组，每个对象示意对应的 promise 后果。

• 当你有多个彼此不依赖的异步工作胜利实现时，或者你总是想晓得每个 promise 的后果时，通常应用它。
• 相比之下，Promise.all() 更适宜彼此相互依赖或者在其中任何一个 reject 时立刻完结。

参数 iterable 是一个可迭代的对象，例如 Array，其中每个成员都是 Promise。

对于每个后果对象，都有一个 status 字符串。如果它的值为 fulfilled，则后果对象上存在一个 value。如果值为 rejected，则存在一个 reason。value（或 reason）反映了每个 promise 决定（或回绝）的值。

举个🌰：

let p1=Promise.resolve(1)
let p2=Promise.reject(2)
let p3=Promise.resolve(3)
let p4=Promise.reject(4)
Promise.allSettled([p1,p2,p3,p4]).then(res=>{console.log(res)
})
    // 返回了一个数组
    [{status: 'fulfilled', value: 1},
{status: 'rejected', reason: 2},
{status: 'fulfilled', value: 3},
{status: 'rejected', reason: 4}]

 class MyPromise {
        static PENDING = 'pending'
        static FULFILLED = 'fulfilled'
        static REJECTED = 'rejected'
        constructor(executor) {
          this.PromiseState = MyPromise.PENDING
          this.PromiseResult = null
          this.fulfilledCallBacks = []
          this.rejectedCallBacks = []
          try {executor(this.resolve.bind(this), this.reject.bind(this))
          } catch (error) {this.reject(error)
          }
        }
        resolve(result) {if ((this.PromiseState = MyPromise.PENDING)) {setTimeout(() => {
              this.PromiseState = MyPromise.FULFILLED
              this.PromiseResult = result
              for (const callBack of this.fulfilledCallBacks) {callBack(result)
              }
            })
          }
        }
        reject(reason) {if ((this.PromiseState = MyPromise.PENDING)) {setTimeout(() => {
              this.PromiseState = MyPromise.REJECTED
              this.PromiseResult = reason
              for (const callBack of this.rejectedCallBacks) {callBack(reason)
              }
            })
          }
        }
        then(onFulfilled, onRejected) {
          onFulfilled =
            typeof onFulfilled === 'function' ? onFulfilled : (val) => val
          onRejected =
            typeof onRejected === 'function'
              ? onRejected
              : (err) => {throw err}
          return new MyPromise((resolve, reject) => {if (this.PromiseState === MyPromise.PENDING) {this.fulfilledCallBacks.push(() => {setTimeout(() => {let x = onFulfilled(this.PromiseResult)
                  x instanceof MyPromise ? x.then(resolve, reject) : resolve(x)
                })
              })
              this.rejectedCallBacks.push(() => {setTimeout(() => {let x = onRejected(this.PromiseResult)
                  x instanceof MyPromise ? x.then(resolve, reject) : reject(x)
                })
              })
            } else if (this.PromiseState === MyPromise.FULFILLED) {
              try {setTimeout(() => {let x = onFulfilled(this.PromiseResult)
                  x instanceof MyPromise ? x.then(resolve, reject) : resolve(x)
                })
              } catch (error) {reject(error)
              }
            } else {
              try {setTimeout(() => {let x = onRejected(this.PromiseResult)
                  x instanceof MyPromise ? x.then(resolve, reject) : reject(x)
                })
              } catch (error) {reject(error)
              }
            }
          })
        }

        //value 要解析为 Promise 对象的值
        static resolve(value) {
          // 如果是
          if (value instanceof MyPromise) {return value} else if (value && typeof value === 'object' && 'then' in value) {return new MyPromise((resolve, reject) => {value.then(resolve, reject)
            })
          }
          return new MyPromise((resolve) => {resolve(value)
          })
        }
        static allSettled(promiseList) {if (Array.isArray(promiseList)) {return new MyPromise((resolve, reject) => {
              let count = 0
              let result = []
              // 如果传入的是一个空数组，那么就间接返回一个 resolved 的空数组 promise 对象
              if (promiseList.length === 0) {return resolve(promiseList)
              }
              promiseList.forEach((item, index) => {MyPromise.resolve(item).then((res) => {
                      count++
                      result[index] = {
                        status: MyPromise.FULFILLED,
                        value: res,
                      }
                      count === promiseList.length && resolve(result)
                    },
                    (error) => {
                      count++
                      result[index] = {
                        status: MyPromise.REJECTED,
                        reason: error,
                      }
                      count === promiseList.length && resolve(result)
                    }
                  )
              })
            })
          } else {throw TypeError('argument must be Array')
          }
        }
      }

      // 测试代码

      const promise1 = MyPromise.resolve(3)
      const promise2 = 1
      const promises = [promise1, promise2]

      MyPromise.allSettled(promises).then((results) =>
        results.forEach((result) => console.log(result))
      )

      setTimeout(() => {const p1 = MyPromise.resolve(3)
        const p2 = new MyPromise((resolve, reject) =>
          setTimeout(reject, 100, 'foo')
        )
        const ps = [p1, p2]

        MyPromise.allSettled(ps).then((results) =>
          results.forEach((result) => console.log(result))
        )
      }, 1000)

      MyPromise.allSettled([]).then((results) => console.log(results))
// 打印后果
(0) []
{status: 'fulfilled', value: 3}
{status: 'fulfilled', value: 1}
{status: 'fulfilled', value: 3}
{status: 'rejected', reason: 'foo'}

\

实现 Promise.any

Promise.any() 接管一个 Promise 可迭代对象，只有其中的一个 promise 胜利，就返回那个曾经胜利的 promise。

如果可迭代对象中没有一个 promise 胜利（即所有的 promises 都失败 / 回绝），就返回一个失败的 promise 和 AggregateError 类型的实例，它是 Error 的一个子类，用于把繁多的谬误汇合在一起。

• 如果传入的参数是一个空的可迭代对象，则返回一个 已失败（already rejected）状态的 Promise。
• 如果传入的参数不蕴含任何 promise，则返回一个 异步实现（asynchronously resolved）的 Promise。(将非 Promise 值，转换为 Promise 并当做胜利)
• 只有传入的迭代对象中的任何一个 promise 变成胜利（resolve）状态，或者其中的所有的 promises 都失败，那么返回的 promise 就会 异步地（当调用栈为空时）变成胜利 / 失败（resolved/reject）状态。(如果所有 Promise 都失败，则报错)

 class MyPromise {
        static PENDING = 'pending'
        static FULFILLED = 'fulfilled'
        static REJECTED = 'rejected'
        constructor(executor) {
          this.PromiseState = MyPromise.PENDING
          this.PromiseResult = null
          this.fulfilledCallBacks = []
          this.rejectedCallBacks = []
          try {executor(this.resolve.bind(this), this.reject.bind(this))
          } catch (error) {this.reject(error)
          }
        }
        resolve(result) {if ((this.PromiseState = MyPromise.PENDING)) {setTimeout(() => {
              this.PromiseState = MyPromise.FULFILLED
              this.PromiseResult = result
              for (const callBack of this.fulfilledCallBacks) {callBack(result)
              }
            })
          }
        }
        reject(reason) {if ((this.PromiseState = MyPromise.PENDING)) {setTimeout(() => {
              this.PromiseState = MyPromise.REJECTED
              this.PromiseResult = reason
              for (const callBack of this.rejectedCallBacks) {callBack(reason)
              }
            })
          }
        }
        then(onFulfilled, onRejected) {
          onFulfilled =
            typeof onFulfilled === 'function' ? onFulfilled : (val) => val
          onRejected =
            typeof onRejected === 'function'
              ? onRejected
              : (err) => {throw err}
          return new MyPromise((resolve, reject) => {if (this.PromiseState === MyPromise.PENDING) {this.fulfilledCallBacks.push(() => {setTimeout(() => {let x = onFulfilled(this.PromiseResult)
                  x instanceof MyPromise ? x.then(resolve, reject) : resolve(x)
                })
              })
              this.rejectedCallBacks.push(() => {setTimeout(() => {let x = onRejected(this.PromiseResult)
                  x instanceof MyPromise ? x.then(resolve, reject) : reject(x)
                })
              })
            } else if (this.PromiseState === MyPromise.FULFILLED) {
              try {setTimeout(() => {let x = onFulfilled(this.PromiseResult)
                  x instanceof MyPromise ? x.then(resolve, reject) : resolve(x)
                })
              } catch (error) {reject(error)
              }
            } else {
              try {setTimeout(() => {let x = onRejected(this.PromiseResult)
                  x instanceof MyPromise ? x.then(resolve, reject) : reject(x)
                })
              } catch (error) {reject(error)
              }
            }
          })
        }
        catch(onRejected) {return this.then(undefined, onRejected)
        }
        //value 要解析为 Promise 对象的值
        static resolve(value) {
          // 如果是
          if (value instanceof MyPromise) {return value} else if (value && typeof value === 'object' && 'then' in value) {return new MyPromise((resolve, reject) => {value.then(resolve, reject)
            })
          }
          return new MyPromise((resolve) => {resolve(value)
          })
        }
        static any(promiseList) {if (Array.isArray(promiseList)) {return new MyPromise((resolve, reject) => {
              let count = 0
              let errors = []
              // 留神留神：如果传入的参数是一个空的可迭代对象，则返回一个 已失败（already rejected）状态的 Promise。if (promiseList.length === 0) return reject(new AggregateError('All promises were rejected'));
              promiseList.forEach((item, index) => {MyPromise.resolve(item).then((res) => {resolve(res)
                  },
                  (reason) => {
                    count++
                    errors.push(reason)
                    /**+                            * 如果可迭代对象中没有一个 promise 胜利，就返回一个失败的 promise 和 AggregateError 类型的实例，+                            * AggregateError 是 Error 的一个子类，用于把繁多的谬误汇合在一起。+                            */
                    count === promiseList.length &&
                      reject(new AggregateError(errors))
                  }
                )
              })
            })
          } else {throw TypeError('argument must be Array')
          }
        }
      }

      // 测试代码

      MyPromise.any([]).catch((e) => {console.log(e)
      })

      const pErr = new Promise((resolve, reject) => {reject('总是失败')
      })

      const pSlow = new Promise((resolve, reject) => {setTimeout(resolve, 500, '最终实现')
      })

      const pFast = new Promise((resolve, reject) => {setTimeout(resolve, 100, '很快实现')
      })

      Promise.any([pErr, pSlow, pFast]).then((value) => {console.log(value)
        // 冀望输入: "很快实现"
      })

      const pErr1 = new MyPromise((resolve, reject) => {reject('总是失败')
      })

      const pErr2 = new MyPromise((resolve, reject) => {reject('总是失败')
      })

      const pErr3 = new MyPromise((resolve, reject) => {reject('总是失败')
      })

      MyPromise.any([pErr1, pErr2, pErr3]).catch((e) => {console.log(e)
      })
      // 打印后果
//       AggregateError: All promises were rejected
// AggregateError: All promises were rejected
// 很快实现

实现 race 办法

Promise.race(iterable) 办法返回一个 promise，一旦迭代器中的某个 promise 解决或回绝，返回的 promise 就会解决或回绝。

一个待定的 Promise 只有给定的迭代中的一个 promise 解决或回绝，就采纳第一个 promise 的值作为它的返回值，从而异步地解析或回绝（一旦堆栈为空）。

race 函数返回一个 Promise，它将与第一个传递的 promise 雷同的实现形式被实现。它能够是实现（resolves），也能够是失败（rejects），这要取决于第一个实现的形式是两个中的哪个。

• 如果传的迭代是空的，则返回的 promise 将永远期待。
• 如果迭代蕴含一个或多个非承诺值和 / 或已解决 / 回绝的承诺，则 Promise.race 将解析为迭代中找到的第一个值。

  class MyPromise {
        static PENDING = 'pending'
        static FULFILLED = 'fulfilled'
        static REJECTED = 'rejected'
        constructor(executor) {
          this.PromiseState = MyPromise.PENDING
          this.PromiseResult = null
          this.fulfilledCallBacks = []
          this.rejectedCallBacks = []
          try {executor(this.resolve.bind(this), this.reject.bind(this))
          } catch (error) {this.reject(error)
          }
        }
        resolve(result) {if ((this.PromiseState = MyPromise.PENDING)) {setTimeout(() => {
              this.PromiseState = MyPromise.FULFILLED
              this.PromiseResult = result
              for (const callBack of this.fulfilledCallBacks) {callBack(result)
              }
            })
          }
        }
        reject(reason) {if ((this.PromiseState = MyPromise.PENDING)) {setTimeout(() => {
              this.PromiseState = MyPromise.REJECTED
              this.PromiseResult = reason
              for (const callBack of this.rejectedCallBacks) {callBack(reason)
              }
            })
          }
        }
        then(onFulfilled, onRejected) {
          onFulfilled =
            typeof onFulfilled === 'function' ? onFulfilled : (val) => val
          onRejected =
            typeof onRejected === 'function'
              ? onRejected
              : (err) => {throw err}
          return new MyPromise((resolve, reject) => {if (this.PromiseState === MyPromise.PENDING) {this.fulfilledCallBacks.push(() => {setTimeout(() => {let x = onFulfilled(this.PromiseResult)
                  x instanceof MyPromise ? x.then(resolve, reject) : resolve(x)
                })
              })
              this.rejectedCallBacks.push(() => {setTimeout(() => {let x = onRejected(this.PromiseResult)
                  x instanceof MyPromise ? x.then(resolve, reject) : reject(x)
                })
              })
            } else if (this.PromiseState === MyPromise.FULFILLED) {
              try {setTimeout(() => {let x = onFulfilled(this.PromiseResult)
                  x instanceof MyPromise ? x.then(resolve, reject) : resolve(x)
                })
              } catch (error) {reject(error)
              }
            } else {
              try {setTimeout(() => {let x = onRejected(this.PromiseResult)
                  x instanceof MyPromise ? x.then(resolve, reject) : reject(x)
                })
              } catch (error) {reject(error)
              }
            }
          })
        }
        catch(onRejected) {return this.then(undefined, onRejected)
        }
        //value 要解析为 Promise 对象的值
        static resolve(value) {
          // 如果是
          if (value instanceof MyPromise) {return value} else if (value && typeof value === 'object' && 'then' in value) {return new MyPromise((resolve, reject) => {value.then(resolve, reject)
            })
          }
          return new MyPromise((resolve) => {resolve(value)
          })
        }
        static race(promiseList) {if (Array.isArray(promiseList)) {return new MyPromise((resolve, reject) => {
              // 留神留神：如果传入的参数是一个空的可迭代对象，则永远为 pending 状态
              if (promiseList.length > 0) {promiseList.forEach((item, index) => {
                  /**                   * 如果迭代蕴含一个或多个非承诺值和 / 或已解决 / 回绝的承诺，* 则 Promise.race 将解析为迭代中找到的第一个值。*/
                  MyPromise.resolve(item).then(resolve, reject)
                })
              }
            })
          } else {throw TypeError('argument must be Array')
          }
        }
      }

      // 测试代码

      /**       * 验证 Promise.race()办法       */

      // 数组全是非 Promise 值，测试通过
      let p1 = Promise.race([1, 3, 4])
      setTimeout(() => {console.log('p1 :>>', p1) //1
      })

      // 空数组，测试通过
      let p2 = Promise.race([])
      setTimeout(() => {console.log('p2 :>>', p2) //pengding
      })

      //  p1 :>>  Promise {<fulfilled>: 1}
      //   p2 :>>  Promise {<pending>}

总结: