实现一个基本的Promise（JavaScript）

Promise

Promise 是 JavaScript 中一种用于处理异步操作的对象。它代表了异步操作的最终完成（或失败）及其结果值。Promise 的主要目的是提供一个更加强大、灵活和表达性强的方式来处理异步操作，替代传统的回调函数。
特点：

1. 状态：Promise 有三种状态：

• Pending（等待）：初始状态，既不是成功，也不是失败。
• Fulfilled（已成功）：意味着操作成功完成。
• Rejected（已失败）：意味着操作失败。

2. 不可变： 一旦 Promise 的状态从 Pending 变为 Fulfilled 或 Rejected，这个状态就不能被改变。

3. 单次： Promise 只会被处理一次。一旦它的状态改变，后续的 then 或 catch 调用都会立即执行。

4. **链式调用：**可以使用 .then() 和 .catch() 方法来添加处理 Promise 的成功或失败的回调函数，这些方法返回一个新的 Promise，使得可以进行链式调用。

代码实现

    class LEPromise {    
      //定义三种状态
      static PENDING = "pending";
      static FULFILLED = "fulfilled";
      static REJECTED = "rejected";
      constructor(executor) { // executor就是new Promise((reslove,reject)=>{}) 传入的(reslove,reject)=>{...}函数
      

      this.status = LEPromise.PENDING // 当前的状态 创建时为PENDING
      this.value = null // 当前值
      this.reason = null // 失败的原因
  
      //这里是因为如果用了setTimeout的话 放延迟后执行的函数数组
      this.onResolvedCallbacks = [] // 存放成功的回调函数队列
      this.onRejectedCallbacks = [] // 存放失败的回调函数队列
  
      // resolve 函数
      const resolve = (value) => {
        if (this.status === LEPromise.PENDING) {
          this.status = LEPromise.FUIFILLED // 将状态置为fulfilled
          this.value = value
          // 执行所有保存的fulfilled函数
          this.onResolvedCallbacks.forEach(fn => fn())
        }
      }
  
      // reject 函数
      const reject = (reason) => {
        if (this.status === LEPromise.PENDING) { 
          this.status = LEPromise.REJECTED // 将状态置为REJECTED
          this.reason = reason
          // 执行所有保存的rejected函数
          this.onRejectedCallbacks.forEach(fn => fn())
        }
      }
  
      // 捕获异常 用于处理用户resolve/reject了抛出的错误，例如throw Error('xxxxx')
      try {
        executor(resolve, reject)
      } catch (err) {
        reject(err)
      }
    }

    
      // -->重写了then函数，用promise包起来了  因为then需要返回一个新的promise 实现链式调用
      then(onFulfilled, onRejected) {
        // 处理onFulfilled, onRejected为空的情况，防止then丢失上一个then返回的值
        onFulfilled = typeof onFulfilled == 'function' ? onFulfilled : x => x;
        onRejected = typeof onRejected == 'function' ? onRejected : err => { throw err }
    
        // 每次调用then都返回一个全新的promise,把之前收集then回调函数的逻辑放到 new Promise()里面
        const promise2 = new Promise((resolve, reject) => {
          // 成功的回调
          if (this.status === LEPromise.FUIFILLED) {
            try {
              // resolve的返回值传给新的promise的结果
              const x = onFulfilled(this.value)
              resolve(x)
            } catch (err) {
              // reject的返回值传给新的promise的失败的结果
              reject(err)
            }
          }
          // 失败的回调
          if (this.status === LEPromise.REJECTED) {
            try {
              const x = onRejected(this.reason)
              resolve(x) // onRejected返回的普通值会作为下一个then的reslove的值（promise规范）
            } catch (err) {
              reject(err)
            }
          }
          // 如果是等待状态，就把res,rej的处理回调函数放入对应的队列里
          if (this.status === LEPromise.PENDING) {
            // 放入成功回调队列
            this.onResolvedCallbacks.push(() => {
              // 额外的逻辑
              if (this.status === LEPromise.FULFILLED) {
                try {
                  const x = onFulfilled(this.value)
                  resolve(x)
                } catch (err) {
                  reject(err)
                }
              }
            })
            // 放入失败回调队列
            this.onRejectedCallbacks.push(() => {
              try {
                const x = onRejected(this.reason)
                resolve(x)
              } catch (err) {
                reject(err)
              }
            })
          }
        })
        // 返回新的promise供下一个then调用
        return promise2;
      }
    }
  
      
    // 例子
    const promise = new LEPromise((resolve, reject) => {  
       resolve("niha");  
    })
    promise.then(
      value => {
        console.log(value, '1')
        return 'return'
      }
    ).then(
      value => {         
        console.log(value, '2')
        return 'otherValue'
      }
    ).then().then( // 空then不会影响return的值
      value => console.log(value, '3')
    )

上面的代码基本符合了Promise/A+的规范

1. 状态定义
2. 构造函数
3. resolve和reject函数
4. 回调队列
5. 异常捕获
6. then方法
7. 链式调用
   这个代码实现了基本的Promise对象实现