自定义Promise实现与ES6类实现的对比分析-优快云博客

自定义Promise

普通构造函数类型

// 声明构造函数
function Promise(excutor) {
  // 添加属性
  this.PromiseState = 'pending';
  this.PromiseResult = null;
  // 声明属性  解决异步任务
  this.callbacks = [];
  // 预先保存实例对象的 this 值
  const self = this;  // self _this that
  // resolve 函数
  function resolve(data) {
    // 判断状态  实现状态只能修改一次
    if (self.PromiseState !== 'pending') return;
    // 1. 修改对象的状态（PromiseState）
    self.PromiseState = 'fulfilled'; // resolved
    // 2. 设置对象结果值（PromiseResult）
    self.PromiseResult = data;
    // 调用成功的回调函数  
    setTimeout(() => {
      self.callbacks.forEach(item => {
        item.onResolved(data)
      })
    });
  }
  // reject 函数
  function reject(data) {
    // 判断状态 实现状态只能修改一次
    if (self.PromiseState !== 'pending') return;
    // 1. 修改对象的状态（PromiseState）
    self.PromiseState = 'rejected'; // resolved
    // 2. 设置对象结果值（PromiseResult）
    self.PromiseResult = data;
    // 调用失败的回调函数 
    setTimeout(() => {
      self.callbacks.forEach(item => {
        item.onRejected(data)
      })
    });
  }
  try {
    // 同步调用 【执行器函数】
    excutor(resolve, reject);
  } catch (e) {
    // 修改 Promise 对象状态为 【失败】
    reject(e)
  }
}
// 添加 then 方法
Promise.prototype.then = function (onResolved, onRejected) {
  const self = this;
  // 判断回调函数的参数（没有第二个参数）  实现异常穿透的原理 
  if (typeof onRejected !== 'function') {
    onRejected = reason => {
      throw reason
    }
  }
  if (typeof onResolved !== 'function') {
    onResolved = value => value
  }
  return new Promise((resolve, reject) => {
    // 封装函数
    function callback(type) {
      try {
        let result = type(self.PromiseResult)
        // 判断
        if (result instanceof Promise) {
          // 如果是 Promise 类型的对象
          result.then(v => {
            resolve(v)
          }, r => {
            reject(r)
          })
        } else {
          // 结果的对象状态为成功
          resolve(result)
        }
      } catch (e) {
        reject(e)
      }
    }
    // 调用回调函数  PromiseState
    if (this.PromiseState === 'fulfilled') {
      setTimeout(() => {
        callback(onResolved)
      });
    }
    if (this.PromiseState === 'rejected') {
      setTimeout(() => {
        callback(onRejected)
      });
    }
    // 判断 pending 状态
    if (this.PromiseState === 'pending') {
      // 保存回调函数
      this.callbacks.push({
        onResolved: function () {
          callback(onResolved)
        },
        onRejected: function () {
          callback(onRejected)
        }
      })
    }
  })
}
// 添加 catch 方法
Promise.prototype.catch = function (onRejected) {
  return this.then(undefined, onRejected);
}
// 添加 resolve 方法
Promise.resolve = function (value) {
  // 返回promise对象
  return new Promise((resolve, reject) => {
    if (value instanceof Promise) {
      value.then(v => {
        resolve(v)
      }, r => {
        reject(r)
      })
    } else {
      // 状态设置为成功
      resolve(value)
    }
  })
}
// 添加 reject 方法
Promise.reject = function (reason) {
  return new Promise((resolve, reject) => {
    reject(reason)
  })
}
// 添加 all 方法
Promise.all = function (promises) {
  // 返回结果为promise对象
  return new Promise((resolve, reject) => {
    // 声明变量
    let count = 0;
    let arr = []; // 存放成功结果的数组
    // 遍历
    for (let i = 0; i < promises.length; i++) {
      promises[i].then(v => {
        // 得知对象的状态是成功的
        // 多个promise对象都成功
        count++;
        // 将当前promise对象成功的结果存入到arr中
        // arr.push(v);
        arr[i] = v;
        // 判断
        if (count === promises.length) {
          // 修改状态
          resolve(arr)
        }
      }, r => {
        reject(r)
      })

    }
  })
}
// 添加 race 方法
Promise.race = function(promises){
  return new Promise((resolve,reject)=>{
    for (let i = 0; i < promises.length; i++) {
      promises[i].then(v=>{
        // 修改返回对象的状态为 成功
        resolve(v)
      },r=>{
        // 修改返回对象的状态为 失败
        reject(r)
      })
      
    }
  })
}

ES6 Class 类型

class Promise {
  // 构造方法
  constructor(excutor) {
    // 添加属性
    this.PromiseState = 'pending';
    this.PromiseResult = null;
    // 声明属性  解决异步任务
    this.callbacks = [];
    // 预先保存实例对象的 this 值
    const self = this;  // self _this that
    // resolve 函数
    function resolve(data) {
      // 判断状态  实现状态只能修改一次
      if (self.PromiseState !== 'pending') return;
      // 1. 修改对象的状态（PromiseState）
      self.PromiseState = 'fulfilled'; // resolved
      // 2. 设置对象结果值（PromiseResult）
      self.PromiseResult = data;
      // 调用成功的回调函数  
      setTimeout(() => {
        self.callbacks.forEach(item => {
          item.onResolved(data)
        })
      });
    }
    // reject 函数
    function reject(data) {
      // 判断状态 实现状态只能修改一次
      if (self.PromiseState !== 'pending') return;
      // 1. 修改对象的状态（PromiseState）
      self.PromiseState = 'rejected'; // resolved
      // 2. 设置对象结果值（PromiseResult）
      self.PromiseResult = data;
      // 调用失败的回调函数 
      setTimeout(() => {
        self.callbacks.forEach(item => {
          item.onRejected(data)
        })
      });
    }
    try {
      // 同步调用 【执行器函数】
      excutor(resolve, reject);
    } catch (e) {
      // 修改 Promise 对象状态为 【失败】
      reject(e)
    }
  }

  then(onResolved, onRejected) {
    const self = this;
    // 判断回调函数的参数（没有第二个参数）  实现异常穿透的原理 
    if (typeof onRejected !== 'function') {
      onRejected = reason => {
        throw reason
      }
    }
    if (typeof onResolved !== 'function') {
      onResolved = value => value
    }
    return new Promise((resolve, reject) => {
      // 封装函数
      function callback(type) {
        try {
          let result = type(self.PromiseResult)
          // 判断
          if (result instanceof Promise) {
            // 如果是 Promise 类型的对象
            result.then(v => {
              resolve(v)
            }, r => {
              reject(r)
            })
          } else {
            // 结果的对象状态为成功
            resolve(result)
          }
        } catch (e) {
          reject(e)
        }
      }
      // 调用回调函数  PromiseState
      if (this.PromiseState === 'fulfilled') {
        setTimeout(() => {
          callback(onResolved)
        });
      }
      if (this.PromiseState === 'rejected') {
        setTimeout(() => {
          callback(onRejected)
        });
      }
      // 判断 pending 状态
      if (this.PromiseState === 'pending') {
        // 保存回调函数
        this.callbacks.push({
          onResolved: function () {
            callback(onResolved)
          },
          onRejected: function () {
            callback(onRejected)
          }
        })
      }
    })
  }

  catch(onRejected) {
    return this.then(undefined, onRejected);
  }

  static resolve(value) {
    // 返回promise对象
    return new Promise((resolve, reject) => {
      if (value instanceof Promise) {
        value.then(v => {
          resolve(v)
        }, r => {
          reject(r)
        })
      } else {
        // 状态设置为成功
        resolve(value)
      }
    })
  }

  static reject(reason) {
    return new Promise((resolve, reject) => {
      reject(reason)
    })
  }

  static all(promises) {
    // 返回结果为promise对象
    return new Promise((resolve, reject) => {
      // 声明变量
      let count = 0;
      let arr = []; // 存放成功结果的数组
      // 遍历
      for (let i = 0; i < promises.length; i++) {
        promises[i].then(v => {
          // 得知对象的状态是成功的
          // 多个promise对象都成功
          count++;
          // 将当前promise对象成功的结果存入到arr中
          // arr.push(v);
          arr[i] = v;
          // 判断
          if (count === promises.length) {
            // 修改状态
            resolve(arr)
          }
        }, r => {
          reject(r)
        })

      }
    })
  }

  static race(promises) {
    return new Promise((resolve, reject) => {
      for (let i = 0; i < promises.length; i++) {
        promises[i].then(v => {
          // 修改返回对象的状态为 成功
          resolve(v)
        }, r => {
          // 修改返回对象的状态为 失败
          reject(r)
        })

      }
    })
  }
}