await 仅在 async 函数中有效

Posted 2023-03-07

【中文标题】await 仅在 async 函数中有效

【英文标题】：await is only valid in async function

【发布时间】：2022-01-15 13:52:41

【问题描述】：

这段代码我写在lib/helper.js

var myfunction = async function(x,y) 
   ....
   return [variableA, variableB]

exports.myfunction = myfunction;

然后我尝试在另一个文件中使用它

 var helper = require('./helper.js');   
 var start = function(a,b)
     ....
     const result = await helper.myfunction('test','test');
 
 exports.start = start;

我遇到了一个错误

"await 只在异步函数中有效"

有什么问题？

【问题讨论】：

嗯，问题是await 只能在async 函数中使用。也就是说，await 使函数异步，因此必须这样声明。

当前错误是什么？

还是一样，SyntaxError: await is only valid in async function

你需要分享更多关于你的代码的上下文。

How do I return the response from an asynchronous call?的可能重复

【参考方案1】：

在这篇不错的文章中找到以下代码：HTTP requests in Node using Axios

const axios = require('axios')

const getBreeds = async () => 
  try 
    return await axios.get('https://dog.ceo/api/breeds/list/all')
   catch (error) 
    console.error(error)
  


const countBreeds = async () => 
  const breeds = await getBreeds()

  if (breeds.data.message) 
    console.log(`Got $Object.entries(breeds.data.message).length breeds`)
  


countBreeds()

或者使用 Promise：

const axios = require('axios')

const getBreeds = () => 
  try 
    return axios.get('https://dog.ceo/api/breeds/list/all')
   catch (error) 
    console.error(error)
  


const countBreeds = async () => 
  const breeds = getBreeds()
    .then(response => 
      if (response.data.message) 
        console.log(
          `Got $Object.entries(response.data.message).length breeds`
        )
      
    )
    .catch(error => 
      console.log(error)
    )


countBreeds()

【参考方案2】：

要使用await，它的执行上下文本质上需要是async

正如它所说，你需要先定义你的executing context 的性质，你愿意await 一个任务在任何事情之前。

只需将async 放在fn 声明之前，您的async 任务将在该声明中执行。

var start = async function(a, b)  
  // Your async task will execute with await
  await foo()
  console.log('I will execute after foo get either resolved/rejected')

说明：

在您的问题中，您正在导入一个method，它本质上是asynchronous，并将并行执行。但是，您尝试执行 async 方法的位置在另一个 execution context 内，您需要定义 async 以使用 await。

 var helper = require('./helper.js');   
 var start = async function(a,b)
     ....
     const result = await helper.myfunction('test','test');
 
 exports.start = start;

想知道引擎盖下发生了什么

await 使用 promise/future/返回任务的方法/函数，async 将方法/函数标记为能够使用 await。

另外，如果你熟悉promises，await 实际上是在做同样的 promise/resolve 过程。创建一个承诺链并在resolve回调中执行你的下一个任务。

更多信息可以参考MDN DOCS。

【讨论】：

即使在启动函数中使用异步我也会收到错误

我不确定您在哪里丢失并收到此错误，没有如此复杂的解释来解决此错误。

这是一个正确的答案，实际上解释了下划线的原因。投票赞成。

【参考方案3】：

如果您在 foreach 中调用了异步函数，请将其更新为 for 循环

【参考方案4】：

这在一个文件中有效..

看起来 await 只应用于必须是异步的本地函数..

我现在也在为更复杂的结构和不同文件之间的关系而苦苦挣扎。这就是我制作这个小测试代码的原因。

编辑：我忘了说我正在使用 node.js.. sry。我没有明确的问题。只是觉得这可能对讨论有所帮助..

    function helper(callback)



    function doA()

        var array = ["a ","b ","c "];

        var alphabet = "";

        return new Promise(function (resolve, reject) 

            array.forEach(function(key,index)

            alphabet += key;

                if (index == array.length - 1)

                    resolve(alphabet);

                ;

            );

        );

    ;



    function doB()

        var a = "well done!";

        return a;

    ;



    async function make() 

        var alphabet = await doA();
        var appreciate = doB();

        callback(alphabet+appreciate);

    ;

    make();

;

helper(function(message)

    console.log(message);

);

【讨论】：

你的问题有问题，即....不是问题。你说你在苦苦挣扎，所以告诉我们你为什么苦苦挣扎，并提出一个中肯的问题......

【参考方案5】：

如果您正在编写 Chrome 扩展程序并且您的代码在根目录中出现此错误，您可以使用以下“解决方法”修复它：

async function run() 
    // Your async code here
    const beers = await fetch("https://api.punkapi.com/v2/beers");


run();

基本上，您必须将异步代码包装在 async function 中，然后在不等待的情况下调用该函数。

【讨论】：

你知道为什么在 chrome 中会发生这种情况吗？

【参考方案6】：

async/await 是处理promise的机制，我们可以有两种方法

functionWhichReturnsPromise()
            .then(result => 
                console.log(result);
            )
            .cathc(err => 
                console.log(result);

            );

或者我们可以使用 await 来等待 promise 先完整提交它，这意味着它要么被拒绝，要么被解决。

现在，如果我们想在函数中使用 await（等待实现的承诺），容器函数必须是异步函数，因为我们正在等待异步实现的承诺||有道理吗？

async function getRecipesAw()
            const IDs = await getIds; // returns promise
            const recipe = await getRecipe(IDs[2]); // returns promise
            return recipe; // returning a promise
        

        getRecipesAw().then(result=>
            console.log(result);
        ).catch(error=>
            console.log(error);
        );

【讨论】：

是的，确实如此。为了调用异步函数，您需要在调用者中使用 await，并且因为您需要在那里等待，所以该函数也可能是异步的。基本上，如果你想使用 async/await，你将不得不在整个应用程序的所有函数中使用它。

【参考方案7】：

错误不是指myfunction，而是指start。

async function start() 
   ....

   const result = await helper.myfunction('test', 'test');

---

// My function
const myfunction = async function(x, y) 
  return [
    x,
    y,
  ];


// Start function
const start = async function(a, b) 
  const result = await myfunction('test', 'test');
  
  console.log(result);


// Call start
start();

---

---

我利用这个问题的机会向您提供有关使用 await 的已知反模式的建议，即：return await。

---

错误

async function myfunction() 
  console.log('Inside of myfunction');


// Here we wait for the myfunction to finish
// and then returns a promise that'll be waited for aswell
// It's useless to wait the myfunction to finish before to return
// we can simply returns a promise that will be resolved later

// useless async here
async function start() 
  // useless await here
  return await myfunction();


// Call start
(async() => 
  console.log('before start');

  await start();
  
  console.log('after start');
)();

---

正确

async function myfunction() 
  console.log('Inside of myfunction');


// Here we wait for the myfunction to finish
// and then returns a promise that'll be waited for aswell
// It's useless to wait the myfunction to finish before to return
// we can simply returns a promise that will be resolved later

// Also point that we don't use async keyword on the function because
// we can simply returns the promise returned by myfunction
function start() 
  return myfunction();


// Call start
(async() => 
  console.log('before start');

  await start();
  
  console.log('after start');
)();

---

另外，知道return await 是正确且重要的特殊情况：（使用try/catch）

Are there performance concerns with `return await`?

【讨论】：

但这不起作用，我更新了我的代码。我仍然得到同样的错误

@j.doe 我添加了一个 sn-p

谢谢，我找到了我的问题。我试图在回调中做到这一点是 start() 函数。解决方案是： const start = async function(a, b) task.get(options, async function (error, result1) const result = await myfunction('test', 'test');

考虑到 Node 是单线程的。它是否会减少每分钟的请求并增加填充请求之间的延迟。

值得一提的是，在 "CORRECT" 示例中，没有必要将 start 声明为 async 函数（尽管有些人会选择这样做，以便更显式）

【参考方案8】：

"await 只在异步函数中有效"

但是为什么呢？ 'await' 显式地将异步调用转换为同步调用，因此调用者不能是异步的（或异步的） - 至少不是因为调用是在 'await' 进行的。

【讨论】：

实际上，await 不会等待结果——它会立即返回一个 Promise。这正是我试图传达的。如果 await 实际上等待并且没有将控制权返回给调用者，那么任何包含 await 关键字的函数实际上都不能被标记为异步。但取而代之的是，我们有任何包含 await 的函数或调用一个最终调用包含 await 的函数的函数必须是异步的。基本上，如果你调用一次 await - 你的所有函数都必须标记为异步。

不。它不会“将异步调用转换为同步调用”。 Async/await 仍然是异步的——它只是看起来是同步的。这是我的大问题，tbh......它“太聪明了”并且假装它不是，只是邀请用户绊倒。结帐生成器函数和“yield”以了解实际发生的情况，尽管我发现这更令人头疼。

【参考方案9】：

我遇到了同样的问题，下面的代码块给出了同样的错误信息：

repositories.forEach( repo => 
        const commits = await getCommits(repo);
        displayCommit(commits);
);

问题在于方法 getCommits() 是异步的，但我传递给它的参数 repo 也是由 Promise 生成的。所以，我不得不像这样添加 async 这个词：async(repo) 并且它开始工作了：

repositories.forEach( async(repo) => 
        const commits = await getCommits(repo);
        displayCommit(commits);
);

【讨论】：

非常感谢！我在两个小时后阅读了这个答案 XD

【参考方案10】：

是的，await / async 是一个很棒的概念，但是实现完全被破坏了。

无论出于何种原因，await 关键字已被实现为只能在异步方法中使用。这实际上是一个错误，尽管您不会在任何地方看到它被这样称呼，但就在这里。此错误的修复将是实现 await 关键字，以便它只能用于调用异步函数，而不管调用函数本身是同步的还是异步的。

由于这个错误，如果您在代码中的某处使用 await 调用真正的异步函数，那么您的所有函数都必须标记为异步，并且您的所有函数调用都必须使用 await。

这实质上意味着您必须将承诺的开销添加到整个应用程序中的所有函数中，其中大部分不是并且永远不会是异步的。

如果你真的考虑过，在函数中使用 await 应该要求包含 await 关键字的函数不能异步 - 这是因为 await 关键字将在找到 await 关键字的函数中暂停处理。如果该函数中的处理被暂停，那么它肯定不是异步的。

所以，对于 javascript 和 ECMAScript 的开发人员 - 请按如下方式修复 await/async 实现...

await 只能用于调用异步函数。 await 可以出现在任何类型的函数中，同步或异步。 将错误消息从“await 仅在异步函数中有效”更改为“await 只能用于调用异步函数”。

【讨论】：

如果你愿意，你可以称它为错误，但我不同意。没有“暂停”的代码之类的东西 - 相反，如果没有某些外部进程（通常是 io）的结果，有些代码无法完成。这样的代码应该被称为“异步”，因为许多外部进程应该能够同时运行（非同步），与单线程的 javascript VM 相比。如果您有许多功能需要重构为async，这反映了您的许多功能需要外部流程的结果这一事实。在我看来，这是完全规范的。

还值得一提的是，将await 限制为仅可用于函数调用的一个可怕缺点：对于单个外部进程，当该进程完成时，只能通知javascript 代码中的一个点。例如，如果一个文件的内容需要用于 3 个独立目的，每个目的都需要独立执行 let content = await readTheFile(); - 这是因为不能等待“文件内容的承诺”，只有“读取文件并恢复的行为”一旦被阅读”。

好吧，我们不叫它暂停的代码，或者不能完成的代码，但是阻塞等待怎么样。这就是问题所在 - 被阻塞等待或无法完成的函数是包含 await 关键字的函数。使用 await 关键字调用的不是异步函数。因此，包含 await 关键字的函数绝对不应该被标记为异步 - 它被阻塞等待，这与异步相反。

为了清楚地说明这一点，请考虑以下内容 - await 旨在通过使它们看起来是同步的来简化异步函数的使用（即它允许我按特定顺序执行操作）。将包含 await 的函数强制为异步是完全用词不当 - 您使用 await 使其变为同步。一个包含 await 的函数绝对不是异步函数！！！

@Gershom - 这听起来很合理。谢谢！

【参考方案11】：

async/await 的当前实现仅支持async 函数内部的await 关键字更改您的start 函数签名，以便您可以在start 内部使用await。

 var start = async function(a, b) 

 

对于那些感兴趣的人，***await 的提案目前处于第 2 阶段：https://github.com/tc39/proposal-top-level-await

【讨论】：

不幸的是，这基本上意味着您必须在整个代码库中使所有函数异步。因为如果要使用 await，则必须在异步函数中执行，这意味着您必须在调用它的函数中等待该函数的响应 - 再次，这意味着您的所有函数都需要变为异步。对我来说，这意味着 await async 还没有准备好使用。当你可以使用await调用一个async方法时，不管当前函数是同步还是异步，那么它都准备好了。

通过任何级别的间接依赖于外部进程结果的每个函数都必须并且应该用async定义 - 这就是全部async的点。

您目前可以使用--experimental-repl-await选项在节点repl中使用它。

【参考方案12】：

当我收到这个错误时，原来我在“异步”函数中调用了映射函数，所以这个错误消息实际上是指映射函数没有被标记为“异步”。我通过从 map 函数中取出“await”调用并想出一些其他方法来获得预期的行为来解决这个问题。

var myfunction = async function(x,y) 
    ....
    someArray.map(someVariable =>  // <- This was the function giving the error
        return await someFunction(someVariable);
    );

【讨论】：

这对我来说是个问题。我用 for 循环替换了 map 函数，这对我来说是一个简单的解决方案。但是，根据您的代码，此解决方案可能不适合您。

仅供参考，您也可以这样做someArray.map(async (someVariable) => return await someFunction(someVariable))

代码中的await 具有误导性，因为Array.map 不会将该函数作为异步函数处理。明确地说，map 函数完成后，someFunction 将全部挂起。如果你真的想等待函数完成，你必须写：await Promise.all(someArray.map(someVariable => someFunction(someVariable))) 或 await Promise.all(someArray.map(someFunction)))。