手写promise异步

### 回答1：
手写Promise异步的方法如下：

// 定义Promise构造函数
function MyPromise(fn) {
  // 状态机，初始化为pending
  var state = 'pending';
  // 成功结果
  var value = null;
  // 失败原因
  var reason = null;
  // 成功回调函数队列
  var successCallback = [];
  // 失败回调函数队列
  var failCallback = [];

  // resolve方法
  function resolve(newValue) {
    if (state === 'pending') {
      state = 'fulfilled';
      value = newValue;
      successCallback.forEach(function(cb) {
        cb(value);
      });
    }
  }

  // reject方法
  function reject(newReason) {
    if (state === 'pending') {
      state = 'rejected';
      reason = newReason;
      failCallback.forEach(function(cb) {
        cb(reason);
      });
    }
  }

  // then方法
  this.then = function(onFulfilled, onRejected) {
    if (state === 'fulfilled') {
      onFulfilled(value);
    }
    if (state === 'rejected') {
      onRejected(reason);
    }
    if (state === 'pending') {
      successCallback.push(onFulfilled);
      failCallback.push(onRejected);
    }
  }

  // 执行fn函数
  fn(resolve, reject);
}

使用方式为:

var promise = new MyPromise(function(resolve, reject) {
  setTimeout(function() {
    resolve('成功');
  }, 1000);
});

promise.then(function(value) {
  console.log(value);
}, function(reason) {
  console.log(reason);
});

这样就实现了一个简单的promise异步.

### 回答2：
手写Promise异步的实现：

Promise是一种用于处理异步操作的机制，通过它可以更加方便地处理异步代码，避免了回调地狱问题。

下面是一个手写的简单Promise异步实现例子：

class MyPromise {
  constructor(executor) {
    this.status = 'pending'; // 初始状态为pending
    this.value = undefined;  // 存储Promise的值
    this.callbacks = [];     // 存储then方法的回调函数

    const resolve = (value) => {
      if (this.status === 'pending') {  // 只能由pending状态转换为fulfilled
        this.status = 'fulfilled';
        this.value = value;
        this.callbacks.forEach(callback => callback(value));
      }
    };

    const reject = (reason) => {
      if (this.status === 'pending') {  // 只能由pending状态转换为rejected
        this.status = 'rejected';
        this.value = reason;
        this.callbacks.forEach(callback => callback(null, reason));
      }
    };

    try {
      executor(resolve, reject);  // 执行executor函数
    } catch (error) {
      reject(error);  // 若存在错误则reject
    }
  }

  then(onFulfilled, onRejected) {
    return new MyPromise((resolve, reject) => {
      const fulfilled = (value) => {
        try {
          const result = onFulfilled(value);
          if (result instanceof MyPromise) {
            result.then(resolve, reject);
          } else {
            resolve(result);
          }
        } catch (error) {
          reject(error);
        }
      };

      const rejected = (reason) => {
        try {
          const result = onRejected(reason);
          if (result instanceof MyPromise) {
            result.then(resolve, reject);
          } else {
            resolve(result);
          }
        } catch (error) {
          reject(error);
        }
      };

      if (this.status === 'fulfilled') {
        setTimeout(() => fulfilled(this.value));  // 异步执行onFulfilled函数
      } else if (this.status === 'rejected') {
        setTimeout(() => rejected(this.value));   // 异步执行onRejected函数
      } else {  // 当前状态是pending时，将回调函数存储到callbacks中
        this.callbacks.push(fulfilled);
        this.callbacks.push(rejected);
      }
    });
  }
}

// 使用例子：
const promise = new MyPromise((resolve, reject) => {
  setTimeout(() => {
    resolve('success');
  }, 1000);
});

promise.then((value) => {
  console.log(value);  // 输出'success'
}).catch((reason) => {
  console.error(reason);
});

这个简单的Promise实现例子中，我们根据Promise的状态定义了resolve和reject函数，同时使用了setTimeout模拟异步处理。在then方法中，根据当前Promise的状态执行相应的回调函数，并处理返回值为Promise的情况。最后使用该Promise实例的时候，可以通过then方法获取resolve的值，或者通过catch方法处理reject的情况。

### 回答3：
手写Promise异步，可以通过自己实现Promise的构造函数和其原型方法来完成。

首先定义一个Promise的构造函数，接收一个执行函数(executor)作为参数。在构造函数中，需要定义三个状态常量：PENDING、FULFILLED和REJECTED，分别代表Promise的三种状态。同时还需要定义一个变量存储Promise的结果。构造函数中，需要定义一个resolve函数和一个reject函数，用于改变Promise的状态，并传递结果。

接下来，需要定义Promise的原型方法，包括then方法和catch方法。then方法接收两个参数，分别是onFulfilled和onRejected，分别代表Promise状态变为FULFILLED和REJECTED时的回调函数。在then方法中，根据当前Promise的状态，执行相应的回调函数，并将结果传递给下一个Promise。

catch方法用于捕获Promise链中的错误，当之前的Promise状态变为REJECTED时，会执行catch方法中的回调函数。

最后，在手动实现的Promise中，任意时间只能处于一种状态，一旦Promise的状态确定，就不可以再次改变。

总的来说，手写Promise异步，需要定义Promise的构造函数，实现resolve和reject函数来改变Promise的状态。然后定义then方法和catch方法来处理结果或错误。这样就能实现一个简单的手动Promise异步函数了。