手写promise 函数

好的，以下是一个简单的手写 Promise 函数实现：

function MyPromise(fn) {
  var self = this;
  self.value = null;
  self.error = null;
  self.onFulfilled = null;
  self.onRejected = null;

  function resolve(value) {
    self.value = value;
    self.onFulfilled(self.value);
  }

  function reject(error) {
    self.error = error;
    self.onRejected(self.error);
  }

  fn(resolve, reject);
}

MyPromise.prototype.then = function(onFulfilled, onRejected) {
  var self = this;
  self.onFulfilled = onFulfilled;
  self.onRejected = onRejected;
};

这个 Promise 实现仅仅是一个简单的演示，还有很多需要完善的地方，比如处理异步操作、链式调用、错误处理等等。

相关问题

手写promise函数

好的，关于手写实现Promise函数，其实Promise是一种异步编程的解决方案，它的本质是对回调函数的封装，可以更加优雅和简洁地处理异步操作。以下是一个简单的手写Promise函数示例：

function MyPromise(fn) {
  var self = this;
  self.status = 'pending';
  self.value = null;
  self.reason = null;
  self.onFulfilledCallbacks = [];
  self.onRejectedCallbacks = [];

  function resolve(value) {
    if (self.status === 'pending') {
      self.status = 'fulfilled';
      self.value = value;
      self.onFulfilledCallbacks.forEach(function(callback) {
        callback(self.value);
      });
    }
  }

  function reject(reason) {
    if (self.status === 'pending') {
      self.status = 'rejected';
      self.reason = reason;
      self.onRejectedCallbacks.forEach(function(callback) {
        callback(self.reason);
      });
    }
  }

  try {
    fn(resolve, reject);
  } catch (e) {
    reject(e);
  }
}

MyPromise.prototype.then = function(onFulfilled, onRejected) {
  var self = this;
  return new MyPromise(function(resolve, reject) {
    if (self.status === 'fulfilled') {
      try {
        var x = onFulfilled(self.value);
        resolve(x);
      } catch (e) {
        reject(e);
      }
    } else if (self.status === 'rejected') {
      try {
        var x = onRejected(self.reason);
        resolve(x);
      } catch (e) {
        reject(e);
      }
    } else if (self.status === 'pending') {
      self.onFulfilledCallbacks.push(function(value) {
        try {
          var x = onFulfilled(value);
          resolve(x);
        } catch (e) {
          reject(e);
        }
      });
      self.onRejectedCallbacks.push(function(reason) {
        try {
          var x = onRejected(reason);
          resolve(x);
        } catch (e) {
          reject(e);
        }
      });
    }
  });
}

以上就是一个简单的手写Promise函数的实现，它是基于回调函数的封装实现的异步编程方案。

手写promise中函数的参数为什么可以是函数形式

在手写 Promise 中，函数的参数可以是函数形式，是因为 Promise 的特性之一：支持链式调用（链式调用也称为方法链接）。Promise 的 then 方法返回的是一个新的 Promise 对象，因此可以继续调用 then 方法或者 catch 方法，形成链式调用。

当我们调用 then 方法时，我们需要传入一个函数作为回调函数，这个回调函数会在 Promise 的状态发生变化时执行。这个回调函数会接收到 Promise 的状态值作为参数，如果状态是 resolved，那么回调函数的第一个参数就是 resolved 的值；如果状态是 rejected，那么回调函数的第一个参数就是 rejected 的原因。因此，当我们使用函数作为 then 方法的参数时，我们就可以在回调函数中对 resolved 或 rejected 的值进行处理，从而实现链式调用的效果。

举个例子，假设我们有一个返回 Promise 对象的函数，我们可以这样写：

asyncFunc()
  .then(function(result) {
    // 对 resolved 的值进行处理
    return anotherAsyncFunc(result);
  })
  .then(function(anotherResult) {
    // 对 anotherAsyncFunc 返回的 resolved 值进行处理
  })
  .catch(function(error) {
    // 对 rejected 的值进行处理
  });

在上面的代码中，我们使用了函数作为 then 方法的参数，然后在回调函数中对 resolved 或 rejected 的值进行处理。这样，我们就实现了链式调用的效果，从而更加方便地处理异步任务的结果。