Javascript 如何等待异步函数？

我的情况是：

let waiting=函数（）{
返回新承诺（解决=>{
console.log（'waiting…'）；
setTimeout（函数（）{
解决（）；
}, 1000)
});
};
让waitingAsync=异步函数（）{
log（'start…'）；
等待等待；
console.log（'stop…'）；
};
waitingAsync（）；
console.log（'done…'）

Async

关键字，用于指定函数将是

AsyncFunction

的实例，因此它将返回

Promise

Await

用于在异步函数内部等待承诺解析

---

---

-异步函数可以包含一个

await

表达式，该表达式暂停异步函数的执行并等待传递的承诺的解析，然后恢复异步函数的执行并返回已解析的值。

这不是一个函数，而是它返回的一个值，该值由

await

语句等待

async

和普通函数与调用者没有什么不同

async

在被调用时只返回一个承诺，而不显式返回它。

waitingAsync（）

调用的结果是一个承诺。

waiting（）

调用的结果也是一个承诺，因此它不是“同步的”

根据，承诺和非承诺都可以

wait

ed。非承诺通过

Promise.resolve（）

转换为承诺

console.log（'done…'）

不能等待，因为它不是在

async

函数中调用的。而且它不必是

wait

ed，因为它不返回承诺，而是

undefined

<代码>等待ing可以在

异步

功能中执行。这些

await

用法是相等的，同样无用，它们所做的只是1个勾号延迟：

async function ... {
  ...
  await console.log('done...');
}

async function ... {
  ...
  console.log('done...');
  await undefined;
}

async function ... {
  ...
  await Promise.resolve(console.log('done...'));
}

---

async

函数确实返回一个承诺，或者，当它使用

wait

关键字时，它必须等待一个异步函数，即一个承诺或另一个

async

函数。在代码中，

waiting（）

是一个返回承诺的函数。然后，

wait waiting（）

是正确的（因为它正在等待异步函数）

---

调用

异步

函数时调用另一个基本函数。当您希望将函数作为异步函数操作并使用'await'关键字时，可以将其标记为异步。之所以打印“done…”，是因为当您调用

asyncFunction（）

时，它必须

等待

，直到

等待承诺

完成。但是程序没有停止并继续显示

done…

。如果您想等待它，也许可以使用

asyncFunction（）。然后（（）=>console.log（'done…）

当您等待一个函数时，如果该函数返回一个承诺，它的返回值将被视为承诺

然后
值。如果承诺被拒绝，它将被判为错误。如果函数调用返回的值大于一个thenable，那么，
await
就不会什么都没有

另一方面，当您声明一个
async
函数时，它的返回值将作为承诺返回，从中抛出的任何错误都将被转换为被拒绝的承诺

只能在声明的
async
函数中使用
wait

这就是所谓的
async
和
await
都是自动兑现承诺。实际上，您不需要使用await和async来实现真正的异步（然而，这并不是很有用）

快速演示：

//Will return the string 'Promise' if called through `await`
function getPromise(){
    return Promise.resolve('Promise');
}

//Casted to Promise.reject thrught await 
function throwError(){
    return Promise.reject('error'); 
}

function get(){
    return 'something simple'; 
}

async function getAsync() {
    var response = await getPromise();
    return response;
}
//await will cast the rejected Promise to an error
async function getErrorAsync() {
    var response = await throwError();
    return response;
}

async function simpleGet(){
    return get();
}

async function redundantGet(){
    return await get();
}

    async function catchTheError(){
      try{
          await throwError();
      }       
      catch(e){
         console.log('an error: ' + e );
      }
       return 'whatever';
 }

getAsync().then( console.log ); //Promise
getErrorAsync().catch( console.log ); //error
simpleGet().then( console.log ); //something simple
redundantGet().then( console.log ); //something simple
catchTheError(); //will log 'an error: error'.

因此：

等待是一个同步函数（因为它没有async关键字）。那么，为什么我可以等待同步函数呢

因为你可以。
等待
做的唯一一件事就是将承诺转化为实际值和错误。实际上，您不需要函数来返回承诺

为什么做不到。。。完成waitingAsync功能后是否等待消息

async
和
await
只会使您的代码表现为同步iside
async
声明的函数。您的最后一个
console.log（'done'）
在任何
async
函数之外，因此它将在该函数结束之前被记录，因为它是异步的

主要问题：waitingAsync是一个异步函数，为什么调用它时不需要wait关键字？只需waitingAsync（）而不是waitingAsync（）

因为
async
关键字将值强制转换为承诺-并允许使用
wait
-仅此而已。事实上，由于只能在
async
函数中使用
wait
。。。您不能期望通过
wait
调用
async
函数，您需要无限的
async
函数：-D.
在开始之前，最好注意一些事情。

代码段的任何读取器

let waiting=函数（）{
返回新承诺（解决=>{
console.log（'waiting…'）；
setTimeout（函数（）{resolve（）；}，1000）；
});
};
让waitingAsync=异步函数（）{
log（'start…'）；
等待等待；
console.log（'stop…'）；
};
waitingAsync（）；
console.log（'done…'）；

可能会被误导，以为输出会

start...
awaiting...
stop...
done...

正如您已经注意到的那样，
完成了…

之前会被打印出来

停止…

原因是

waitingAsync（）是对异步函数的调用，
而
console.log（'done…'）只是一个正常的顺序/同步
立即执行的声明


问题1：

waiting
是一个同步函数（因为它没有
async
关键词）[？]

回答：

False。函数
waiting
是a同步的–它返回
承诺


瞿