JS：异步函数隐含地解开承诺？

Question

据我所知，异步函数将它们的返回值隐式包装到一个 Promise 中。这对所有属性都有效，除了 Promises 本身。

async function f() {
  return new Promise((res) => {
    setTimeout(() => {
      res("Why am I being unwrapped")
    }, 1000)
  })
}

(async () => {
  console.log(await f())
})()

那些在被退回之前会被打开。这样await f() 实际上就在等待两个嵌套的 Promise。

请注意，这也适用于显式创建的 Promises (Promise.resolve(new Promise(...)))

有没有好的方法来避免这种情况？我真的很想有一个没有像这样的快速修复的嵌套 Promise。

async function y() {
  return {wrapped: new Promise((res) => {
    setTimeout(() => {
      res("Why am I being unwrapped")
    }, 1000)
  })}
}

(async () => {
  console.log((await y()).wrapped)
})()

Sandbox

Answer 1

根据MDN documentation on async functions：

异步函数总是返回一个承诺。如果异步函数的返回值不是显式的 Promise，它将被隐式包装在 Promise 中。

换句话说，由于您返回的是 Promise，因此它不会被包装。如果你想重新包装它，你可以，但你也可以去掉 async 具有类似效果的关键字。你会得到原始的 Promise，除非你await它。

如此有效：

function f() {
  return new Promise((res) => {
    setTimeout(() => {
      res("Might be wrappers on some of you, but not on me!")
    }, 1000)
  })
}

(async () => {
  console.log(f())
})()

这会给你这样的输出：

Promise { <pending> }

如果目标是拥有一个返回原始 Promise 的 Promise，那么您将与 Promise 系统设计的所有功能作斗争，即在发现 Promise 时自动解包。 Promise.resolve() 包装了所有但 Promise，如果你以某种方式给它一个 Promise，它会递归地解包。

您可以通过返回不是 Promise 的东西来做到这一点，就像在您的示例中一样，但这似乎违背了 Promise 的全部目的。

如果您尝试解决的特定问题绝对需要延迟 Promise，请考虑返回一个函数而不是某个任意对象：

function f() {
  return () => {
    return new Promise((res) => {
      setTimeout(() => {
        res("I'll start as soon as you ask.")
      }, 1000)
    })
  };
}

然后，当您想获得实际的 Promise 时，您可以致电 let p = f() 和稍后的 p()。这就是 JavaScript 通常处理延迟执行的方式。

如果你想立即启动 Promise 的执行，你仍然可以适应：

function f() {
  const p = new Promise((res) => {
    setTimeout(() => {
      res("Already underway when requested.")
    }, 1000)
  })

  return () => { p };
}

尽管如果可能的话，通常最好避免使用这些技术，而且通常情况下也是如此。