Javascript 等待仅在异步函数中有效

我在

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;

我犯了个错误

“等待仅在异步函数中有效”

---

问题是什么？

错误不是指

myfunction

，而是指

start

async function start() {
   ....

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

---

//我的函数
常量myfunction=异步函数（x，y）{
返回[
x,，
Y
];
}
//启动功能
const start=异步函数（a，b）{
const result=wait myfunction（'test'，'test'）；
控制台日志（结果）；
}
//呼叫开始
start（）

要使用

等待

，其执行上下文本质上需要是

异步

正如上面所说的，您需要定义您的

执行上下文的性质，在这里您愿意在任何事情之前等待任务

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

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

说明：

在您的问题中，您正在导入一个
方法
，该方法本质上是
异步的
，将并行执行。但是，您尝试执行
async
方法的地方位于不同的
执行上下文中，您需要定义
async
以使用
wait

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

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

await
使用承诺/未来/任务返回方法/函数，并且
async
将方法/函数标记为能够使用await

另外，如果您熟悉
承诺
，
等待
实际上也在执行相同的承诺/解决过程。创建承诺链并执行
resolve
回调中的下一个任务

有关更多信息，请参阅。
当我遇到此错误时，原来我在“async”函数中调用了map函数，因此此错误消息实际上是指没有标记为“async”的map函数。我绕过了这个问题，从map函数中调用了“await”，并提出了一些获得预期行为的其他方法

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

var myfunction=异步函数（x，y）{
....
someArray.map（someVariable=>{/当前实现的
async
/
await
只支持
async
函数中的
await
关键字更改
start
函数签名，以便在
start
中使用
await

 var start = async function(a, b) {

 }

对于那些感兴趣的人来说，关于顶级
await
的建议目前正处于第2阶段：
是的，await/async是一个很好的概念，但是实现完全失败了

无论出于何种原因，wait关键字的实现使得它只能在异步方法中使用。这实际上是一个bug，尽管除了这里，您不会在任何地方看到它被称为这样的bug。该bug的修复方法是实现wait关键字，使得它只能用于调用异步函数，而不管在什么情况下调用函数本身是同步的或异步的

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

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

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

因此，对于javascript和ECMAScript的开发人员，请按如下方式修复wait/async实现


wait只能用于调用异步函数
wait可以出现在任何类型的函数中，同步或异步
将错误消息从“wait仅在异步函数中有效”更改为“wait只能用于调用异步函数”
我遇到了相同的问题，下面的代码块给出了相同的错误消息：

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

问题是getCommits（）方法是异步的，但我将参数repo传递给它，该参数也是由一个承诺生成的。因此，我必须向它添加async一词，如下所示：async（repo），它开始工作：

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

“等待仅在异步函数中有效”

但是为什么？'await'显式地将异步调用转换为同步调用，因此调用方不能是异步的（或异步的）-至少不是因为调用是在'await'进行的。
async/await是处理承诺的机制，我们可以通过两种方式来实现

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

            });

或者我们可以使用wait来等待承诺首先提交，这意味着它要么被拒绝，要么被解决

现在，如果我们想在函数中使用wait（等待承诺实现），那么容器函数必须是异步函数，因为我们正在等待承诺异步实现，这是有意义的，对吗

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

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

基本上，您必须将异步代码包装在一个
异步函数中，然后在不等待的情况下调用该函数。
这在一个文件中工作

看起来wait only应用于必须是异步的本地函数

我现在还在为一个更复杂的结构和不同的文件之间挣扎，这就是为什么我要编写这个小测试代码

编辑：我忘了说我正在使用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);

});

嗯，是的
    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);

});