21.自定义封装Promise-同步任务修改 then() 返回值

then() 方法返回的是一个 Promise 对象,所以让 then() 方法有一个 return

  Promise.prototype.then = function (onResolved, onRejected) {
    return new Promise((resolve, reject) => {
      if (this.PromiseState === "resolved") {
        onResolved(this.PromiseResult);
      }
      if (this.PromiseState === "rejected") {
        onRejected(this.PromiseResult);
      }
      if (this.PromiseState === "pending") {
        this.callbacks.push({
          onResolved,
          onRejected,
        });
      }
    });
  };

此时 then() 返回的就是一个 Promise 对象,但是状态是 pending, 结果是 null,所以还需要进行处理

then 返回的 Promise 状态由 then() 指定的回调函数执行的结果决定，也就是onResolved和onRejected决定的

如果抛出异常,状态就是 rejected, reason 就是抛出的异常

如果返回的是非 promise 的任意值, 状态是 resolved,结果就是任意值

如果返回的是 promise,状态就是 promise 的结果状态，值就是promise的结果值

首先先要获取 回调函数的执行结果,然后对其判断

  Promise.prototype.then = function (onResolved, onRejected) {
    return new Promise((resolve, reject) => {
      if (this.PromiseState === "resolved") {
        // 拿到执行结果
        let result = onResolved(this.PromiseResult);
        // 判断
        if (result instanceof Promise) {
          // 如果是 Promise对象,就可以调用 then 方法
          result.then(
            (v) => {
              resolve(v);
            },
            (r) => {
              reject(r);
            }
          );
        } else {
          // 如果不是 Promise 对象, then() 返回的Promise状态就是 resolved, 值就是回调函数的返回值
          // 让状态变成 resolved, res 的状态就是 new Promise的状态,所以调用 resolve()
          resolve(result);
        }
      }
      if (this.PromiseState === "rejected") {
        let result = onRejected(this.PromiseResult);
        if (result instanceof Promise) {
          result.then(
            (v) => {
              resolve(v);
            },
            (r) => {
              reject(r);
            }
          );
        } else {
          resolve(result);
        }
      }
      if (this.PromiseState === "pending") {
        this.callbacks.push({
          onResolved,
          onRejected,
        });
      }
    });
  };

如果是抛出错误,用 try{}catch(e) {}处理

  Promise.prototype.then = function (onResolved, onRejected) {
    return new Promise((resolve, reject) => {
      if (this.PromiseState === "resolved") {
        try {
          let result = onResolved(this.PromiseResult);
          if (result instanceof Promise) {
            result.then(
              (v) => {
                resolve(v);
              },
              (r) => {
                reject(r);
              }
            );
          } else {
            resolve(result);
          }
        } catch (e) {
          reject(e);
        }
      }
      if (this.PromiseState === "rejected") {
        try {
          let result = onRejected(this.PromiseResult);
          if (result instanceof Promise) {
            result.then(
              (v) => {
                resolve(v);
              },
              (r) => {
                reject(r);
              }
            );
          } else {
            resolve(result);
          }
        } catch (e) {
          reject(e);
        }
      }
      if (this.PromiseState === "pending") {
        this.callbacks.push({
          onResolved,
          onRejected,
        });
      }
    });
  };