Await仅在async函数中有效

我在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 is only valid in async function

问题是什么?

631163 次浏览
小开
最佳答案

错误不是指向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)

' return await '有性能问题吗?< / >

小开

要使用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使用承诺/未来/任务返回方法/函数，而async标记一个方法/函数能够使用await。

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

有关更多信息，您可以参考MDN文档。

小开

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

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

async / await的当前实现只支持async函数内部的await关键字。

 var start = async function(a, b) {


}

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

小开

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

不管出于什么原因，await关键字的实现使得它只能在异步方法中使用。这实际上是一个bug，尽管除了这里，您不会在任何地方看到它被称为bug。修复此错误的方法是实现await关键字，使其只能用于调用异步函数，而不管调用函数本身是同步的还是异步的。

由于这个错误，如果你在代码的某个地方使用await来调用一个真正的异步函数，那么你所有的函数都必须被标记为async，并且你所有的函数调用都必须使用await。

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

如果你仔细想想，在函数中使用await应该要求包含await关键字的函数NOT BE ASYNC——这是因为await关键字将暂停找到await关键字的函数中的处理。如果该函数的处理被暂停，那么它肯定不是异步的。

所以，对于javascript和ECMAScript的开发者，请按以下方式修复await/async实现…

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

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

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'显式地将异步调用转换为同步调用，因此调用方不能是异步的(或异步的)——至少不是因为调用是在'await'进行的。

小开

Async /await是处理promise的机制，有两种方式

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


});

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

现在，如果我们想在函数中使用等待(等待承诺履行)，容器函数必须是异步函数，因为我们正在等待承诺异步履行||，这是有意义的，对吗?

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扩展，你得到这个错误的代码在根，你可以修复它使用下面的“工作区”:

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


run();

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

小开

这在一个文件工作..

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


});
小开

如果在foreach中调用了async函数，则将其更新为for循环

小开

在这篇不错的文章中找到下面的代码:使用Axios的Node中的HTTP请求

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()
小开

Express的一个常见问题:

警告可以引用函数 。

快递项目通常是这样的:

app.post('/foo', ensureLoggedIn("/join"), (req, res) => {
const facts = await db.lookup(something)
res.redirect('/')
})

注意该函数的=>箭头函数语法。

问题并不在数据库中。查找调用，但就在这里的快递项目里。

需要:

app.post('/foo', ensureLoggedIn("/join"), async function (req, res) {
const facts = await db.lookup(something)
res.redirect('/')
})

基本上，删除=>并添加async function。


提交答案