在promise中使用wait

Question

必须将promise的回调定义为异步，这似乎有内在的问题：

return new Promise(async (resolve, reject) => {
  const value = await somethingAsynchronous();
  if (value === something) {
    return resolve('It worked!');
  } else {
    return reject('Nope. Try again.');
  }
});

这显然是一种反模式，因此可能会出现编码问题。我知道，即使在try/catch块中放置await语句，也很容易在此处捕获错误。

我的第一个问题是，当一个人想要用不同的resolve/reject值转发一个promise时，编写这样的代码的最佳方式是什么？那么，你要什么？即。

return new Promise((resolve, reject) => {
  somethingAsynchronous().then(value => {
    if (value === something) {
      return resolve('It worked!');
    } else {
      return reject('Nope. Try again.');
    }
  }); // errors would now be propagated up
});

或者你只是按照这里的建议把它全部去掉？

async function outerFunction() {
  const value = await somethingAsynchronous();
  return new Promise((resolve, reject) => {
    if (value === something) {
      return resolve('It worked!');
    } else {
      return reject('Nope. Try again.');
    }
  });
}

但是，您如何解释这样的代码呢？

async function outerFunction() {
  if (someSynchronousCheck()) {
    return 'Nope. Try again.' // another reject case
  }

  const value = await somethingAsynchronous();
  // ...
}

我觉得我把事情弄得比应该的更复杂了。我试图避免嵌套回调/链接然后/捕捉块，而不会在未来产生更多的问题。

我的最后一个问题是，为什么回调传递给一个Promise，而不是本质上的async？它已经封装在一个promise中，并期望异步调用resolve/reject函数。

Answer 1

您也可以通过简单地这样做来链接自己的promise：

return new Promise((resolve, reject) => {
  somethingAsynchronous().then((value) => {
      if (value === something) {
        return resolve('It worked!');
      } else {
        return reject('Nope. Try again.');
      }
  }, (error) => { reject(error); });
});

我用这个已经有一段时间了，它对我非常有效。

Answer 2

新promise（异步（解析、拒绝）=

考虑到promise异步代码可以通过async..await处理，因此promise构造函数的当前用例是非promise异步代码，例如：

new Promise(resolve => setTimeout(resolve, 1000))

当Promise构造函数包含同步代码或涉及其他promise时，应使用async函数构造promise。替代品是asynciLife：

return (async (resolve, reject) => {
  const value = await somethingAsynchronous();
  if (value === something) {
    return 'It worked!';
  } else {
    throw 'Nope. Try again.';
  }
})();

如果与async一起使用时仍然需要Promise构造函数，那么Promise构造函数应该在层次结构中向下移动，这样它就不会包装任何async函数。

我的最后一个问题是，为什么回调传递给一个promise不是天生异步的？它已经封装在一个promise中，并期望异步调用resolve/reject函数。

async函数不仅仅是一个异步执行的函数，它返回另一个应该被利用的promise-或者至少用catch处理。Promise不应该利用从构造中返回的promise函数。

构造函数可以在相同的刻度上解析，并且不一定是异步的。

Promise.resolve(1);

是类似于

Promise(resolve => resolve(1))

而不是去

Promise(resolve => setTimeout(() => resolve(1)))

Answer 3

你这样做：

async function outerFunction() {
  const value = await somethingAsynchronous();
  if (value === something) {
    return 'It Worked!';
  }
  throw Error('Nope. Try again.');
}

使用async将outerFunction的结果包装为一个promise。

如果您想要将包装promise解析为某个东西，只需从async函数返回它。如果您希望包装promise被拒绝，请在async函数中抛出一个错误。

但是，您如何解释这样的代码呢？

async function outerFunction() {
  if (someSynchronousCheck()) {
    throw Error('Nope. Try again.');
  }

  const value = await somethingAsynchronous();
  // ...
}