Javascript 等待最后的指示有用吗

我看过下面的代码，想知道除了强制方法使用

async

关键字外，在最后一条指令上指定wait是否有用？范例

async example(){
  //... whatever code

  //Last instruction
  await functionReturningAPromise()
}

注意，这里我怀疑返回值丢失了，但即使返回了，我的问题仍然存在

async example(){
  //... whatever code

  //Last instruction
  return await functionReturningAPromise() //Is this useful ? or should we return directly
}

---

我个人认为没有真正的兴趣。

我不这么认为-

等待

就像一个断点。

await

ed函数中的所有代码在

await

下面的任何代码之前运行。对于函数中的最后一个调用，这其实并不重要，因此更容易做到：

async function doStuff() {
    await thingOne();
    await thingTwo();
    thingThree(); //You can put await here if you want to, but it's not necessary, 
                  //even if it is asynchronous / returns a Promise
}

---

如果要用try-catch块包围最后一条指令以处理错误，这是有意义的

async example(){
  //... whatever code

  //Last instruction
  try {

   return await functionReturningAPromise()
  } catch(error) {
     // error handling
  }
}

如果不是，则在

返回之后添加
等待
只会引入不必要的承诺，但会产生相同的结果


如果您想确保调用
example（）
后执行的代码在
函数returningagreement（）
解决之前不会被调用，而不使用
返回
时，使用
等待
非常有用。
其他答案（关于try/catch）很有趣。这也是有意义的，因为如果函数内部抛出，它会改变函数的堆栈跟踪

也就是说，如果您在堆栈跟踪中等待
functionreturningagreement
，那么
example
将显示在堆栈跟踪中，如果您不等待，则不会显示。因此，如果您喜欢调试代码，我建议您保持等待状态。=
因此，这是我尝试仅用代码回答我自己的问题。我的结论是

1） 我不同意那种说法，
returnawait
在try/catch块之外是多余的。如果使用
wait

2） 将
await
放在最后一个语句中可以保证，如果I
await example（）
在
functionreturningagreement（）
解决问题后（正如@Kristianmitk所指出的），将执行后面调用的任何操作

3） 使用
await
调用异步函数不能作为
Promise工作。如果在异步函数中启动了多个Promise（而不是
await
-ed），则为all

请参阅测试结果3/4/5。在获得结果后，我将获得慢速异步函数的日志


函数asyncSlow（testName）{
返回新承诺（解决=>{
设置超时（（）=>{
log（'slow是从'+testName'完成的）
解析（'slow-'+testName）；
}, 300);
});
}
函数asyncFast（testName）{
返回新承诺（解决=>{
设置超时（（）=>{
log（'fast是从'+testName'完成的）
解析（'fast-'+testName）；
}, 100);
});
}
异步函数test1（）{
等待asyncSlow（'test1'）
等待asyncFast（'test1'）
}
异步函数test2（）{
等待asyncSlow（'test2'）
return wait asynchfast（'test2'）
}
异步函数test3（）{
asyncSlow（'test3'）
return wait asynchfast（'test3'）
}
异步函数test4（）{
asyncSlow（'test4'））
返回asynchfast（'test4'）
}
异步函数test5（）{
asyncSlow（'test5'））
asynchfast（'test5'）
}
异步函数main（）{
const res=wait test1（）
console.log（'res='+res）
const res2=wait test2（）
console.log（'res2='+res2）
const res3=等待test3（）
console.log（'res3='+res3）
const res4=等待test4（）
console.log（'res4='+res4）
const res5=等待test5（）
console.log（'res5='+res5）
}
main（）。如果两者都不做，只需调用该方法，然后隐式地返回未定义的
return
，我认为它不会成为同一承诺链的一部分。
return wait…
在某些ES linter中生成警告-这（通常）是不必要的。这里有很好的解释-如果
thingtree（）
返回承诺，就不会
doStuff（）
是否在完成之前解决？我认为这里需要使用
await
，以便在
doStuff（）
解析之前完成
thingtree（）
。这是最后一条指令-那又有什么关系呢？如果它是整个链中的最后一条，那么它就无关紧要了（可能除了可读性），但是如果
doStuff（）
将被调用到您希望等待它完成的某个地方，然后不使用
await
会很早解决它，如果不是有意的，这可能会有问题。@ZachBarham但您肯定使用的是
await doStuff（）
在这种情况下，调用代码将是等待承诺解决的代码。它会，但它只会等待
thingOne（）
和
thingTwo（）
，因为它们正在
等待
ed，但是
thingtree（）
不是，也不会返回其承诺。如果有人认为行为应该改变，请告诉我，我会在与v8团队的会议上提出。在您的第二条评论中，您是否暗示il将通过确保在之后调用的任何函数都将等待
函数返回承诺（）
来解决，即使没有使用
等待
关键字调用
示例
，从而将
示例
转换为某种同步？不，您将始终需要
等待
（或。然后（…）以确保在结算
示例之前不会执行后续代码。我想指出的是，最后一个
等待
将在
示例
进入最终状态时产生影响。