aguardar só é válido na função assíncrona

Eu escrevi este código em lib/helper.js

var myfunction = async function(x,y) {
   ....
   reutrn [variableA, variableB]
}
exports.myfunction = myfunction;

e então tentei usá-lo em outro arquivo

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

Eu tenho um erro

"await só é válido na função assíncrona"

Qual é o problema?

O erro não está se referindo a, myfunctionmas a 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();

Eu uso a oportunidade desta questão de aconselhá-lo sobre um anti padrão conhecido usando awaito que é: return await.

ERRADO

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

CORRIGIR

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

Além disso, saiba que há um caso especial em que return awaité correto e importante: (usando try / catch)

Existem preocupações de desempenho com `return await`?

Quando recebi esse erro, descobri que havia uma chamada para a função map dentro da minha função "assíncrona", então essa mensagem de erro estava se referindo à função de mapa não estar marcada como "assíncrona". Eu resolvi esse problema pegando a chamada "esperar" da função de mapa e descobrindo alguma outra maneira de obter o comportamento esperado.

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

Para usar await, seu contexto de execução precisa estar asyncna natureza

Como disse, você precisa definir a natureza de executing contextonde você está disposto a awaituma tarefa antes de qualquer coisa.

Basta colocar asyncantes da fndeclaração na qual sua asynctarefa será executada.

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

Explicação:

Na sua pergunta, você está importando um methodque está asynchronousna natureza e será executado em paralelo. Mas onde você está tentando executar esse asyncmétodo está dentro de um diferente execution contextque você precisa definir asyncpara usar await.

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

Querendo saber o que está acontecendo sob o capô

awaitconsome métodos / funções de promessa / futuro / retorno de tarefa e asyncmarca um método / função como capaz de usar o await.

Além disso, se você estiver familiarizado com o promises, awaitestá realmente fazendo o mesmo processo de promessa / resolução. Criar uma cadeia de promessas e executar a próxima tarefa no resolveretorno de chamada.

Para obter mais informações, você pode consultar o MDN DOCS .

A implementação atual de async/ awaitsuporta apenas a awaitpalavra - chave dentro das asyncfunções. Altere a startassinatura da função para que você possa usar awaitdentro start.

 var start = async function(a, b) {

 }

Para os interessados, a proposta de nível superior awaitestá atualmente na Etapa 2: https://github.com/tc39/proposal-top-level-await

Eu tive o mesmo problema e o seguinte bloco de código estava apresentando a mesma mensagem de erro:

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

O problema é que o método getCommits () era assíncrono, mas eu estava passando para ele o argumento repo, que também foi produzido por uma Promise. Então, eu tive que adicionar a palavra async a ele assim: async (repo) e ele começou a funcionar:

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

async / await é o mecanismo de manipulação de promessa, duas maneiras de fazer isso

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

            });

ou podemos usar await para aguardar a promessa de preenchimento completo primeiro, o que significa que foi rejeitada ou resolvida.

Agora, se quisermos usar await (aguardando o cumprimento de uma promessa) dentro de uma função, é obrigatório que a função de contêiner seja uma função assíncrona porque estamos aguardando que uma promessa seja cumprida de forma assíncrona || faz sentido certo ?.

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 só é válido na função assíncrona"

Mas por que? 'await' transforma explicitamente uma chamada assíncrona em uma chamada síncrona e, portanto, o chamador não pode ser assíncrono (ou asyncable) - pelo menos, não por causa da chamada sendo feita em 'await'.

Sim, await / async era um ótimo conceito, mas a implementação está completamente quebrada.

Por algum motivo, a palavra-chave await foi implementada de forma que só pode ser usada em um método assíncrono. Na verdade, isso é um bug, embora você não vá vê-lo referido como tal em nenhum lugar, exceto aqui. A correção para esse bug seria implementar a palavra-chave await de forma que ela só pudesse ser usada PARA CALL uma função assíncrona, independentemente de a própria função de chamada ser síncrona ou assíncrona.

Devido a esse bug, se você usar await para chamar uma função assíncrona real em algum lugar do código, TODAS as funções devem ser marcadas como assíncronas e TODAS as chamadas de função devem usar await.

Isso significa essencialmente que você deve adicionar a sobrecarga de promessas a todas as funções em todo o seu aplicativo, a maioria das quais não são e nunca serão assíncronas.

Se você realmente pensar sobre isso, o uso de await em uma função deve exigir a função que contém a palavra-chave await TO NOT BE ASYNC - isso ocorre porque a palavra-chave await vai pausar o processamento na função onde a palavra-chave await é encontrada. Se o processamento nessa função for pausado, então definitivamente NÃO é assíncrono.

Portanto, para os desenvolvedores de javascript e ECMAScript - corrija a implementação de await / async como segue ...

• await só pode ser usado para funções assíncronas CALL.
• O await pode aparecer em qualquer tipo de função, síncrona ou assíncrona.
• Altere a mensagem de erro de "await só é válido na função assíncrona" para "await só pode ser usado para chamar funções assíncronas".