await solo es válido en función asincrónica

Escribí este código en lib/helper.js

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

y luego intenté usarlo en otro archivo

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

Tengo un error

"await solo es válido en función asincrónica"

¿Cual es el problema?

El error no se refiere a myfunctionsino 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();

Yo uso la oportunidad de esta pregunta para aconsejarle sobre un patrón conocido de lucha contra el uso de awaitlo que es: return await.

INCORRECTO

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

CORRECTO

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

Además, sepa que hay un caso especial donde return awaites correcto e importante: (usando try / catch)

¿Hay problemas de rendimiento con el "retorno en espera"?

Cuando recibí este error, resultó que tenía una llamada a la función de mapa dentro de mi función "asíncrona", por lo que este mensaje de error en realidad se refería a que la función de mapa no estaba marcada como "asíncrona". Solucioné este problema eliminando la llamada "await" de la función del mapa y encontrando alguna otra forma de obtener el comportamiento esperado.

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

Para usar await, su contexto de ejecución debe estar asyncen la naturaleza

Como se dijo, debe definir la naturaleza de su executing contextlugar en el que está dispuesto a realizar awaituna tarea antes que nada.

Simplemente coloque asyncantes de la fndeclaración en la que asyncse ejecutará su tarea.

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

Explicación:

En su pregunta, está importando un archivo methodque está asynchronousen la naturaleza y se ejecutará en paralelo. Pero donde está intentando ejecutar ese asyncmétodo es dentro de un diferente execution contextque debe 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;

Preguntándome qué pasa bajo el capó

awaitconsume métodos / funciones de promesa / futuro / devolución de tareas y asyncmarca un método / función como capaz de usar await.

Además, si está familiarizado promises, en awaitrealidad está haciendo el mismo proceso de promesa / resolución. Crea una cadena de promesas y ejecuta su próxima tarea en la resolvedevolución de llamada.

Para obtener más información, puede consultar MDN DOCS .

La implementación actual de async/ awaitsolo admite la awaitpalabra clave dentro de las asyncfunciones. Cambie la startfirma de su función para que pueda usarla awaitdentro start.

 var start = async function(a, b) {

 }

Para los interesados, la propuesta de nivel superior se awaitencuentra actualmente en la Etapa 2: https://github.com/tc39/proposal-top-level-await

Tuve el mismo problema y el siguiente bloque de código estaba dando el mismo mensaje de error:

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

El problema es que el método getCommits () era asíncrono pero le estaba pasando el repositorio de argumentos que también fue producido por Promise. Entonces, tuve que agregar la palabra async así: async (repo) y comenzó a funcionar:

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

async / await es el mecanismo de manejo de la promesa, dos formas en que podemos hacerlo

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

            });

o podemos usar await para esperar a que la promesa se complete por completo primero, lo que significa que se rechaza o se resuelve.

Ahora, si queremos usar await (esperando que se cumpla una promesa) dentro de una función, es obligatorio que la función contenedora sea una función asíncrona porque estamos esperando que una promesa se cumpla de forma asincrónica || tiene sentido ¿verdad ?.

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 solo es válido en función asincrónica"

¿Pero por qué? 'await' convierte explícitamente una llamada asíncrona en una llamada síncrona y, por lo tanto, la persona que llama no puede ser asíncrona (o asincable), al menos, no porque la llamada se realice en 'espera'.

Sí, await / async fue un gran concepto, pero la implementación está completamente rota.

Por alguna razón, la palabra clave await se ha implementado de tal manera que solo se puede usar dentro de un método asincrónico. De hecho, esto es un error, aunque no verá que se mencione como tal en ningún otro lugar que no sea aquí. La solución para este error sería implementar la palabra clave await de manera que solo se pueda usar PARA LLAMAR a una función asíncrona, independientemente de si la función de llamada es en sí misma síncrona o asíncrona.

Debido a este error, si usa await para llamar a una función asíncrona real en algún lugar de su código, TODAS sus funciones deben estar marcadas como asíncronas y TODAS sus llamadas a funciones deben usar await.

Básicamente, esto significa que debe agregar la sobrecarga de las promesas a todas las funciones en toda su aplicación, la mayoría de las cuales no son y nunca serán asincrónicas.

Si realmente lo piensa, el uso de await en una función debería requerir que la función que contiene la palabra clave await NO SEA ASINC. Esto se debe a que la palabra clave await pausará el procesamiento en la función donde se encuentra la palabra clave await. Si el procesamiento en esa función está en pausa, definitivamente NO es asíncrono.

Entonces, para los desarrolladores de javascript y ECMAScript, corrijan la implementación de await / async de la siguiente manera ...

• await solo se puede usar para LLAMAR funciones asíncronas.
• await puede aparecer en cualquier tipo de función, sincrónica o asincrónica.
• Cambie el mensaje de error de "await solo es válido en función asíncrona" a "await solo se puede usar para llamar funciones asíncronas".