wait n'est valide que dans la fonction async

J'ai écrit ce code en lib/helper.js

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

puis j'ai essayé de l'utiliser dans un autre fichier

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

J'ai une erreur

"wait n'est valide que dans la fonction async"

Quelle est la solution?

L'erreur ne se réfère pas à myfunctionmais à 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();

J'utilise l'occasion de cette question pour vous conseiller sur un modèle connu en utilisant contre ce awaitqui est: return await.

FAUX

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

CORRECT

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

Sachez également qu'il existe un cas particulier où return awaitest correct et important: (en utilisant try / catch)

Y a-t-il des problèmes de performances avec «return await»?

Quand j'ai eu cette erreur, il s'est avéré que j'avais un appel à la fonction de carte dans ma fonction "async", donc ce message d'erreur faisait en fait référence à la fonction de carte qui n'était pas marquée comme "async". J'ai contourné ce problème en retirant l'appel "await" de la fonction de carte et en proposant un autre moyen d'obtenir le comportement attendu.

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

Pour l'utiliser await, son contexte d'exécution doit être asyncdans la nature

Comme il l'a dit, vous devez avant tout définir la nature de votre situation executing contextoù vous êtes prêt à effectuer awaitune tâche.

Mettez juste asyncavant la fndéclaration dans laquelle votre asynctâche s'exécutera.

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

Explication:

Dans votre question, vous importez un methodqui est asynchronousdans la nature et s'exécutera en parallèle. Mais là où vous essayez d'exécuter cette asyncméthode, c'est à l'intérieur d'un autre execution contextque vous devez définir asyncpour l'utiliser await.

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

Je me demande ce qui se passe sous le capot

awaitconsomme des méthodes / fonctions promises / futures / de retour de tâches et asyncmarque une méthode / fonction comme capable d'utiliser await.

Aussi, si vous êtes familier avec promises, awaitfait en fait le même processus de promesse / résolution. Créer une chaîne de promesse et exécuter votre prochaine tâche en resolverappel.

Pour plus d'informations, vous pouvez vous référer à MDN DOCS .

L'implémentation actuelle de async/ awaitne prend en charge que le awaitmot - clé à l'intérieur des asyncfonctions. Modifiez la startsignature de votre fonction pour pouvoir l'utiliser à l' awaitintérieur start.

 var start = async function(a, b) {

 }

Pour les personnes intéressées, la proposition de top-level awaitest actuellement à l'étape 2: https://github.com/tc39/proposal-top-level-await

J'ai eu le même problème et le bloc de code suivant donnait le même message d'erreur:

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

Le problème est que la méthode getCommits () était asynchrone mais je lui passais l'argument repo qui était également produit par une promesse. Donc, j'ai dû ajouter le mot async comme ceci: async (repo) et cela a commencé à fonctionner:

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

async / await est le mécanisme de gestion de la promesse, deux façons de le faire

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

            });

ou nous pouvons utiliser await pour attendre la promesse de la remplir en premier, ce qui signifie qu'elle est rejetée ou résolue.

Maintenant, si nous voulons utiliser await (en attente d'une promesse à remplir) à l'intérieur d'une fonction, il est obligatoire que la fonction conteneur soit une fonction asynchrone car nous attendons qu'une promesse se réalise de manière asynchrone || fait sens non ?.

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

"wait n'est valide que dans la fonction async"

Mais pourquoi? 'wait' transforme explicitement un appel asynchrone en appel synchrone, et par conséquent l'appelant ne peut pas être asynchrone (ou asyncable) - du moins, pas à cause de l'appel effectué à 'wait'.

Oui, attendre / async était un excellent concept, mais l'implémentation est complètement cassée.

Pour une raison quelconque, le mot-clé await a été implémenté de telle sorte qu'il ne peut être utilisé que dans une méthode async. Il s'agit en fait d'un bogue, même si vous ne le verrez pas désigné comme tel ailleurs que ici. Le correctif de ce bogue serait d'implémenter le mot-clé await de sorte qu'il ne puisse être utilisé que POUR APPELER une fonction asynchrone, que la fonction appelante soit elle-même synchrone ou asynchrone.

En raison de ce bogue, si vous utilisez await pour appeler une fonction asynchrone réelle quelque part dans votre code, alors TOUTES vos fonctions doivent être marquées comme asynchrones et TOUS vos appels de fonction doivent utiliser await.

Cela signifie essentiellement que vous devez ajouter la surcharge des promesses à toutes les fonctions de l'ensemble de votre application, dont la plupart ne sont pas et ne seront jamais asynchrones.

Si vous y réfléchissez réellement, l'utilisation de await dans une fonction devrait nécessiter que la fonction contenant le mot-clé await NE SOIT PAS ASYNC - c'est parce que le mot-clé await va interrompre le traitement dans la fonction où se trouve le mot-clé await. Si le traitement dans cette fonction est interrompu, alors il n'est certainement PAS asynchrone.

Donc, aux développeurs de javascript et d'ECMAScript - veuillez corriger l'implémentation d'attente / async comme suit ...

• wait ne peut être utilisé que pour appeler des fonctions asynchrones.
• Wait peut apparaître dans n'importe quel type de fonction, synchrone ou asynchrone.
• Modifiez le message d'erreur de "Wait est uniquement valide dans la fonction asynchrone" à "Wait peut uniquement être utilisé pour appeler des fonctions asynchrones".