Promise的实现

const PENDING = "PENDING";
const RESOLVED = "RESOLVED";
const REJECTED = "REJECTED";

function Promise(executor) {
  this.status = PENDING;
  this.value = undefined;
  this.onResolvedCallbacks = [];
  this.onRejectedCallbacks = [];

  var self = this;
  function resolve(value) {
    if (value instanceof Promise) {
      return value.then(resolve, reject);
    }
    if (self.status === PENDING) {
      self.status = RESOLVED;
      self.value = value;
      self.onResolvedCallbacks.forEach(function (fn) {
        fn();
      });
    }
  }

  function reject(value) {
    if (self.status === PENDING) {
      self.status = REJECTED;
      self.value = value;
      self.onRejectedCallbacks.forEach(function (fn) {
        fn();
      });
    }
  }

  try {
    executor(resolve, reject);
  } catch (error) {
    reject(error);
  }
}

Promise.prototype.then = function (onResolved, onRejected) {
  onResolved =
    typeof onResolved === "function"
      ? onResolved
      : function (v) {
          return v;
        };
  onRejected =
    typeof onRejected === "function"
      ? onRejected
      : function (err) {
          throw err;
        };
  var self = this;
  var promise2 = new Promise(function (resolve, reject) {
    if (self.status === PENDING) {
      self.onResolvedCallbacks.push(function () {
        setTimeout(function () {
          try {
            var x = onResolved(self.value);
            resolvePromise(promise2, x, resolve, reject);
          } catch (error) {
            reject(error);
          }
        });
      });
      self.onRejectedCallbacks.push(function () {
        setTimeout(function () {
          try {
            var x = onRejected(self.value);
            resolvePromise(promise2, x, resolve, reject);
          } catch (error) {
            reject(error);
          }
        });
      });
    }
    if (self.status === RESOLVED) {
      setTimeout(function () {
        try {
          var x = onResolved(self.value);
          resolvePromise(promise2, x, resolve, reject);
        } catch (error) {
          reject(error);
        }
      });
    }
    if (self.status === REJECTED) {
      setTimeout(function () {
        try {
          var x = onRejected(self.value);
          resolvePromise(promise2, x, resolve, reject);
        } catch (error) {
          reject(error);
        }
      });
    }
  });
  return promise2;
};

function resolvePromise(promise, x, resolve, reject) {
  if (promise === x) {
    return reject(new TypeError("循环引用"));
  }
  var called;
  if (x !== null && (typeof x === "object" || typeof x === "function")) {
    try {
      var then = x.then;
      if (typeof then === "function") {
        then.call(
          x,
          function (y) {
            if (called) return;
            called = true;
            resolvePromise(promise, y, resolve, reject);
          },
          function (err) {
            if (called) return;
            called = true;
            reject(err);
          }
        );
      } else {
        resolve(x);
      }
    } catch (error) {
      if (called) return;
      called = true;
      reject(error);
    }
  } else {
    resolve(x);
  }
}

Promise.defer = Promise.deferred = function () {
  let dfd = {};
  dfd.promise = new Promise((resolve, reject) => {
    dfd.resolve = resolve;
    dfd.reject = reject;
  });
  return dfd;
};
module.exports = Promise;

//npm install -g promises-aplus-tests
//promises-aplus-tests promise.js
//测试通过