await 仅在 async 函数中有效

Question

这段代码我写在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 只在异步函数中有效"

有什么问题？

Answer 1

错误不是指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`?

Answer 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。

Answer 3

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

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

Answer 4

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

 var start = async function(a, b) {

 }

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

Answer 5

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

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

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

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

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

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

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

Answer 6

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

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);
});

Answer 7

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

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

Answer 8

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);
        });

Answer 9

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

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

run();

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

Answer 10

这在一个文件中有效..

看起来 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);

});

Answer 11

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

Answer 12

在这篇不错的文章中找到以下代码：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()