请手写一个Javascript的Promise实现代码

下面是一个简单的JavaScript Promise的实现代码：

// Promise构造函数
function Promise(fn) {
  var self = this;
  self.status = 'pending'; // Promise的状态，默认为pending
  self.value = undefined; // Promise的值，默认为undefined
  self.onResolvedCallback = []; // Promise resolve时的回调函数集合
  self.onRejectedCallback = []; // Promise reject时的回调函数集合

  function resolve(value) {
    if (self.status === 'pending') {
      self.status = 'resolved';
      self.value = value;
      // 依次执行所有的回调函数
      self.onResolvedCallback.forEach(function(callback) {
        callback(value);
      });
    }
  }

  function reject(reason) {
    if (self.status === 'pending') {
      self.status = 'rejected';
      self.value = reason;
      // 依次执行所有的回调函数
      self.onRejectedCallback.forEach(function(callback) {
        callback(reason);
      });
    }
  }

  // 执行传入的函数
  try {
    fn(resolve, reject);
  } catch (e) {
    reject(e);
  }
}

// then方法
Promise.prototype.then = function(onResolved, onRejected) {
  var self = this;
  var promise2;

  // 如果onResolved不是函数，则将其设为一个默认的函数
  onResolved = typeof onResolved === 'function' ? onResolved : function(value) { return value; };
  // 如果onRejected不是函数，则将其设为一个默认的函数
  onRejected = typeof onRejected === 'function' ? onRejected : function(reason) { throw reason; };

  if (self.status === 'resolved') {
    // 如果Promise的状态已经是resolved，则立即执行onResolved函数，并返回一个新的Promise对象
    return promise2 = new Promise(function(resolve, reject) {
      try {
        var x = onResolved(self.value);
        if (x instanceof Promise) {
          // 如果onResolved函数的返回值是一个Promise对象，则直接取其结果作为promise2的结果
          x.then(resolve, reject);
        } else {
          resolve(x);
        }
      } catch (e) {
        reject(e);
      }
    });
  }

  if (self.status === 'rejected') {
    // 如果Promise的状态已经是rejected，则立即执行onRejected函数，并返回一个新的Promise对象
    return promise2 = new Promise(function(resolve, reject) {
      try {
        var x = onRejected(self.value);
        if (x instanceof Promise) {
          // 如果onRejected函数的返回值是一个Promise对象，则直接取其结果作为promise2的结果
          x.then(resolve, reject);
        } else {
          resolve(x);
        }
      } catch (e) {
        reject(e);
      }
    });
  }

  if (self.status === 'pending') {
    // 如果Promise的状态是pending，则将onResolved和onRejected函数分别添加到onResolvedCallback和onRejectedCallback数组中
    return promise2 = new Promise(function(resolve, reject) {
      self.onResolvedCallback.push(function(value) {
        try {
          var x = onResolved(value);
          if (x instanceof Promise) {
            // 如果onResolved函数的返回值是一个Promise对象，则直接取其结果作为promise2的结果
            x.then(resolve, reject);
          } else {
            resolve(x);
          }
        } catch (e) {
          reject(e);
        }
      });

      self.onRejectedCallback.push(function(reason) {
        try {
          var x = onRejected(reason);
          if (x instanceof Promise) {
            // 如果onRejected函数的返回值是一个Promise对象，则直接取其结果作为promise2的结果
            x.then(resolve, reject);
          } else {
            resolve(x);
          }
        } catch (e) {
          reject(e);
        }
      });
    });
  }
};

// 测试代码
var p = new Promise(function(resolve, reject) {
  setTimeout(function() {
    resolve('Hello, World!');
  }, 1000);
});

p.then(function(value) {
  console.log(value); // 输出：Hello, World!
});

这是一个简单的Promise实现，包含了Promise构造函数和then方法。在构造函数中，我们定义了resolve和reject函数，并调用传入的函数。在then方法中，我们根据Promise的状态执行相应的回调函数，并返回一个新的Promise对象