异步/等待与承诺

Question

对最佳实践感到困惑。

Using async-await is better than using promises.是吗？

如何判断aync/await和promises的用途？

下面我只是写了两个代码sn-ps。一个使用aync/await，另一个不使用。

哪个会更快？

CASE 1 的优势是什么？

哪个是最新的方法和优势？

案例一

var promise1 = rp('https://api.example.com/endpoint1');
var promise2 = rp('https://api.example.com/endpoint2');

var response1 = await promise1;
var response2 = await promise2;
return response1 + ' ' + response2;

案例 2

var promise1 = rp('https://api.example.com/endpoint1');
var promise2 = rp('https://api.example.com/endpoint2');

return Promise.all([promise1, promise2])
.then(function(values){
    return values[0] + values[1];
});

Answer 1

使用 async-await 比使用 Promise 更好

没有。 async 和 await 是帮助您管理承诺的工具。

哪个会更快？

不太可能有任何明显的差异

CASE 1 的优势是什么？

有些人会认为它更简单、更容易理解。其他人可能不同意。

Answer 2

Async/await 在底层被翻译成 Promise。

因此，两者的性能是相同的。

您应该始终使用 async/await，除非有一些技术限制，因为它更容易理解。

现在，正如其他人提到的，目前两个代码示例并不相等。 但是由于您使用的是await，这意味着您的rp() 返回了一个承诺。因此，您可以将第一个案例重写为：

let [r1, r2] = await Promise.all([promise1, promise2])
return r1 + r2

为了达到同样的效果。

Answer 3

使用 async-await 比使用 Promise 更好。

哪个会更快？

最新的方法和优势是什么？

无论是语法还是您的任何一种方法都没有提供任何优于另一种的特殊优势，但此外，您的方法并不能很好地显示您的意图。您不需要为了同时获得它们的结果而保留对 Promise 的显式引用：

const [response1, response2] = await Promise.all([
  rp('https://api.example.com/endpoint1'),
  rp('https://api.example.com/endpoint2')
]);
...

请记住，上述方法必须包含在 async 函数中。它不能像这种方法那样存在于顶级范围内：

Promise.all([
  rp('https://api.example.com/endpoint1'),
  rp('https://api.example.com/endpoint2')
]).then(([response1, response2]) => {
  ...
});

Answer 4

Await 用于评估已解决或已拒绝的 Promise。所以使用 .then 和 await 的功能是一样的。但是 await 使代码更具可读性，因为您不会进入一系列回调。使用 await，您可以将异步函数视为使用 await 的同步函数。

让我们举个例子。我们有一个 API 和 2 个数据库，我们想从其中一个数据库中取一个名称并插入到另一个数据库中。为此，我们必须从数据库 1 中获取数据。等待它到达我们的客户端，然后通过 POST 请求将其发送到我们的 API 以插入。 [您可以使用 ONE 功能服务器端完成所有这些操作，但对于我们的案例，我们将发出 2 个异步获取请求来回答这个问题]。如果我们想在函数中使用 .then 来解决这个问题，它看起来像这样。

function get_and_set(){
   fetch("https://www.some_api.com/get_random_name")
   .then( response => response.text() )
     .then( name => {
       fetch("https://www.some_api_2.com/insert_name", {
        headers : {
          "Body-Type"    : "application/json",
          "Accept"       : "application/json"
        },
        method : "POST",
        body : JSON.stringify({ name : name })
      })
      .then( set_response => set_response.text() )
        .then( set_response => {
           return set_response;
        })
     )}

}

如果我们选择使用带有 await 的异步函数，我们可以改为这样。在我个人看来，这变得更具可读性。

async function get_and_set(){
  let response = await fetch("https://www.some_api.com/get_random_name")
  let name = response.text();

  let insert_response = await fetch("https://www.some_api_2.com/insert_name", {
     headers : {
        "Body-Type"    : "application/json",
        "Accept"       : "application/json"
     },
     method : "POST",
     body : JSON.stringify({ name : name })
  });
  let success = insert_response.text();

  return (success); //Return the status of how the insertion went
}

Answer 5

所有当前的回答当然都是正确的，但请记住一些差异。

目前，在您的两个解决方案中，promise 都是并行调用的。这可能会导致一些错误。

考虑这种情况（对您的情况 1 稍作修改）：

var response1 = await rp('https://api.example.com/endpoint1');
var response2 = await rp('https://api.example.com/endpoint2');

return response1 + ' ' + response2;

在上述情况下，promise2 将在 promise1 完成自身执行后执行。当promise2 启动时，结果就已经知道了。另一方面，您的案例在某种竞赛中一起运行。因此，如果在对rp 的第二次调用中包含依赖于在第一次调用rp 时执行的某些操作的逻辑，则可能会导致意外结果甚至崩溃。很好的例子是写入和读取同一个文件。

让我们考虑以下示例：

function writeToFile()
{
   return new Promise((resolve, reject) => {
      ... // writing to file abc.txt
   };
}

function readFile()
{
   return new Promise((resolve, reject) => {
      ... // reading file abc.txt
   };
}

function raceCondition() 
{
   Promise.all([
       writeToFile(),
       readFile()
   ]);
} 

async function asyncAwait() 
{
   await writeToFile();
   await readFile();
} 

raceCondition() 函数可能会导致意外行为，因为 readFile 可能会在 writeToFile 函数甚至没有完成写入文件时运行。它可能导致读取一些旧数据，甚至文件可能不存在。

asyncAwait() 函数使用 async/await 方法来保证writeToFile() 函数在读取开始之前完成其工作。当然这并不意味着程序变得同步。同时执行其他操作（即一些 GUI 事件处理等）。

Async/Await 应被视为 .then().then() 链的替代方案，而不是 Promise.all