await è valido solo nella funzione async

Ho scritto questo codice in formato lib/helper.js

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

e poi ho provato a usarlo in un altro file

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

Ho ricevuto un errore

"await è valido solo nella funzione async"

Qual'è il problema?

L'errore non si riferisce a myfunctionma 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();

Io uso l'occasione di questa domanda per consigliarvi su un noto modello anti usando awaitche è: return await.

SBAGLIATO

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

CORRETTA

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

Inoltre, sappi che c'è un caso speciale in cui return awaitè corretto e importante: (usando try / catch)

Ci sono problemi di prestazioni con "return await"?

Quando ho ricevuto questo errore, si è scoperto che avevo una chiamata alla funzione map all'interno della mia funzione "async", quindi questo messaggio di errore si riferiva effettivamente alla funzione map non contrassegnata come "async". Ho aggirato questo problema eliminando la chiamata "await" dalla funzione map e trovando un altro modo per ottenere il comportamento previsto.

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

Per essere utilizzato await, il contesto di esecuzione deve essere asyncnella natura

Come detto, devi definire la natura del tuo luogo in executing contextcui sei disposto a awaitsvolgere un compito prima di ogni altra cosa.

Basta mettere asyncprima della fndichiarazione in cui asyncverrà eseguita l'attività.

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

Spiegazione:

Nella tua domanda, stai importando un methodche è asynchronousin natura e verrà eseguito in parallelo. Ma dove stai cercando di eseguire quel asyncmetodo è all'interno di un diverso execution contextche devi definire asyncper usare await.

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

Chiedendosi cosa sta succedendo sotto il cofano

awaitconsuma metodi / funzioni di ritorno di promesse / futuro / attività e asynccontrassegna un metodo / funzione come in grado di utilizzare await.

Inoltre, se hai familiarità promises, awaitsta effettivamente facendo lo stesso processo di promessa / risoluzione. Crea una catena di promesse e ti esegue il prossimo compito in resolvecallback.

Per maggiori informazioni puoi fare riferimento a MDN DOCS .

L'attuale implementazione di async/ awaitsupporta solo la awaitparola chiave inside of asyncfunctions Cambia la startfirma della tua funzione in modo da poterla usare awaitinside start.

 var start = async function(a, b) {

 }

Per chi fosse interessato, la proposta di primo livello awaitè attualmente in fase 2: https://github.com/tc39/proposal-top-level-await

Ho avuto lo stesso problema e il seguente blocco di codice dava lo stesso messaggio di errore:

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

Il problema è che il metodo getCommits () era asincrono ma gli stavo passando l'argomento repo che è stato anche prodotto da Promise. Quindi, ho dovuto aggiungere la parola async in questo modo: async (repo) e ha iniziato a funzionare:

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

async / await è il meccanismo di gestione della promessa, due modi in cui possiamo farlo

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

            });

oppure possiamo usare await per attendere che la promessa venga compilata per prima, il che significa che viene rifiutata o risolta.

Ora, se vogliamo usare await (in attesa che una promessa venga mantenuta) all'interno di una funzione, è obbligatorio che la funzione contenitore sia una funzione asincrona perché stiamo aspettando che una promessa venga soddisfatta in modo asincrono || ha senso vero ?.

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 è valido solo nella funzione async"

Ma perché? "await" trasforma esplicitamente una chiamata asincrona in una chiamata sincrona, e quindi il chiamante non può essere asincrono (o asincrono) - almeno, non a causa della chiamata effettuata in "await".

Sì, wait / async era un ottimo concetto, ma l'implementazione è completamente rotta.

Per qualsiasi motivo, la parola chiave await è stata implementata in modo tale da poter essere utilizzata solo all'interno di un metodo asincrono. Questo è in realtà un bug, anche se non lo vedrai indicato come tale da nessuna parte ma proprio qui. La correzione di questo bug sarebbe l'implementazione della parola chiave await in modo tale che possa essere utilizzata solo PER CHIAMARE una funzione asincrona, indipendentemente dal fatto che la funzione chiamante sia sincrona o asincrona.

A causa di questo bug, se usi await per chiamare una vera funzione asincrona da qualche parte nel tuo codice, TUTTE le tue funzioni devono essere contrassegnate come asincrone e TUTTE le tue chiamate di funzione devono usare await.

Ciò significa essenzialmente che è necessario aggiungere il sovraccarico delle promesse a tutte le funzioni dell'intera applicazione, la maggior parte delle quali non sono e non saranno mai asincrone.

Se ci pensate davvero, l'uso di await in una funzione dovrebbe richiedere la funzione contenente la parola chiave await TO NOT BE ASYNC - questo perché la parola chiave await metterà in pausa l'elaborazione nella funzione in cui si trova la parola chiave await. Se l'elaborazione in quella funzione è sospesa, NON è sicuramente asincrona.

Quindi, per gli sviluppatori di javascript ed ECMAScript, correggi l'implementazione di await / async come segue ...

• await può essere utilizzato solo per CALL funzioni asincrone.
• wait può apparire in qualsiasi tipo di funzione, sincrona o asincrona.
• Modificare il messaggio di errore da "await è valido solo nella funzione async" a "await può essere utilizzato solo per chiamare funzioni async".