Question

我看过下面的代码，并且想知道，除了强制该方法具有async关键字之外，在最后一条指令上指定等待是否有用？例子

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
}

我个人没有真正的兴趣。

Answer 1

如果要在最后一条指令的周围加上try-catch块来处理错误，这是很有意义的。

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

  //Last instruction
  try {

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

如果没有，在await之后添加return只会引入不必要的承诺，但会产生相同的结果。

在不使用return的情况下使用await很有用，以防您想确保在调用example()之后执行的代码不会在{{1 }}已解决。

Answer 2

我不这么认为-await就像一个断点。 await函数中的所有代码都在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
}

Answer 3

其他答案（关于try / catch）很有趣。这也很有意义，因为如果其中的函数抛出异常，它将更改函数的堆栈跟踪。

也就是说，example如果在堆栈跟踪中等待functionReturningAPromise，它将显示在堆栈跟踪中，如果您不等待，则不会显示在堆栈跟踪中。因此，如果您希望能够调试代码，建议您保持等待状态。=

Answer 4

所以这是我尝试仅用代码回答我自己的问题的尝试。我的结论是

1）我不同意return await在try / catch块之外是多余的说法。如果使用example()调用，它将更改await的返回值

2）将await放在最后一条语句上将保证，如果我await example()被调用之后的任何事情都将在 functionReturningAPromise()解决之后进行（克里斯蒂安密特指出）。

3）如果您在其中启动了多个promise（而不是在内部await-ed的情况下），则使用Promise.all调用异步函数并不会像await那样工作。）。

查看测试结果3/4/5在获得结果之后，我得到了慢速异步函数的日志。

function asyncSlow(testName){
  return new Promise(resolve => {
      setTimeout(() => {
        console.log('slow is done from' + testName)
        resolve('slow-' + testName);
      }, 300);
    });
}

function asyncFast(testName){
  return new Promise(resolve => {
      setTimeout(() => {
        console.log('fast is done from' + testName)
        resolve('fast-' + testName);
      }, 100);
    });
}

async function test1(){
  await asyncSlow('test1')
  await asyncFast('test1')
}

async function test2(){
  await asyncSlow('test2')
  return await asyncFast('test2')
}

async function test3(){
  asyncSlow('test3')
  return await asyncFast('test3')
}

async function test4(){
  asyncSlow('test4')
  return asyncFast('test4')
}

async function test5(){
  asyncSlow('test5')
  asyncFast('test5')
}

async function main(){
  const res = await test1()
  console.log('res = ' + res)
  
  const res2 = await test2()
  console.log('res2 = ' + res2)
  
  const res3 = await test3()
  console.log('res3 = ' + res3)
  
  const res4 = await test4()
  console.log('res4 = ' + res4)
  
  const res5 = await test5()
  console.log('res5 = ' + res5)
}

main()

这就是输出的样子：

slow is done fromtest1
fast is done fromtest1
res = undefined
slow is done fromtest2
fast is done fromtest2
res2 = fast-test2
fast is done fromtest3
res3 = fast-test3
fast is done fromtest4
res4 = fast-test4
res5 = undefined
slow is done fromtest3
fast is done fromtest5
slow is done fromtest4
slow is done fromtest5

等待上一条指令是否有用

4 个答案: