Warten ist nur in der asynchronen Funktion gültig

Ich habe diesen Code geschrieben lib/helper.js

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

und dann habe ich versucht, es in einer anderen Datei zu verwenden

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

Ich habe einen Fehler bekommen

"Warten ist nur in der asynchronen Funktion gültig"

Was ist das Problem?

Der Fehler bezieht sich nicht auf, myfunctionsondern auf 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();

Ich nutze die Gelegenheit dieser Frage, um Sie über ein bekanntes Anti-Muster zu beraten, awaitdas lautet : return await.

FALSCH

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

RICHTIG

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

Beachten Sie auch, dass es einen Sonderfall gibt, in dem dies return awaitrichtig und wichtig ist: (Verwenden von try / catch)

Gibt es Leistungsprobleme mit "Rückkehr warten"?

Als ich diesen Fehler bekam, stellte sich heraus, dass ich die Kartenfunktion in meiner "asynchronen" Funktion aufgerufen hatte. Diese Fehlermeldung bezog sich also tatsächlich auf die Kartenfunktion, die nicht als "asynchron" markiert war. Ich habe dieses Problem umgangen, indem ich den Aufruf "Warten" aus der Kartenfunktion genommen und eine andere Methode gefunden habe, um das erwartete Verhalten zu erhalten.

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

Um verwendet zu werden await, muss der ausführende Kontext asyncin der Natur liegen

Wie gesagt, Sie müssen vor allem die Art Ihrer Aufgabe definieren, in der executing contextSie zu awaiteiner Aufgabe bereit sind .

Stellen Sie einfach asyncvor die fnDeklaration, in der Ihre asyncAufgabe ausgeführt wird.

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

Erläuterung:

In Ihrer Frage importieren Sie eine, methoddie asynchronousin der Natur liegt und parallel ausgeführt wird. Wenn Sie jedoch versuchen, diese asyncMethode auszuführen, befindet sich eine andere Methode, execution contextdie Sie für die asyncVerwendung definieren müssen await.

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

Ich frage mich, was unter der Haube los ist

awaitverbraucht vielversprechende / zukünftige / aufgabenrückgebende Methoden / Funktionen und asyncmarkiert eine Methode / Funktion als wartungsfähig.

Auch wenn Sie sind vertraut mit promises, awaitist eigentlich den gleichen Prozess der Verheißung / beheben zu tun. Erstellen Sie eine Versprechenskette und führen Sie die nächste Aufgabe im resolveRückruf aus.

Weitere Informationen finden Sie unter MDN DOCS .

Die aktuelle Implementierung von async/ awaitunterstützt nur das awaitSchlüsselwort innerhalb von asyncFunktionen. Ändern Sie Ihre startFunktionssignatur, damit Sie sie awaitinnerhalb verwenden können start.

 var start = async function(a, b) {

 }

Für Interessenten befindet sich der Vorschlag für die oberste Ebene awaitderzeit in Phase 2: https://github.com/tc39/proposal-top-level-await

Ich hatte das gleiche Problem und der folgende Codeblock gab die gleiche Fehlermeldung aus:

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

Das Problem ist, dass die Methode getCommits () asynchron war, aber ich habe ihr das Argument repo übergeben, das auch von einem Promise erzeugt wurde. Also musste ich das Wort async wie folgt hinzufügen: async (repo) und es fing an zu funktionieren:

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

async / await ist der Mechanismus für den Umgang mit Versprechen, zwei Möglichkeiten, wie wir dies tun können

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

            });

oder wir können warten verwenden, um auf das Versprechen zu warten, es zuerst vollständig einzureichen, was bedeutet, dass es entweder abgelehnt oder gelöst wird.

Wenn wir nun await (Warten auf die Erfüllung eines Versprechens) innerhalb einer Funktion verwenden möchten, muss die Containerfunktion eine asynchrone Funktion sein, da wir darauf warten, dass ein Versprechen asynchron erfüllt wird || Sinn machen, oder?.

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

"Warten ist nur in der asynchronen Funktion gültig"

Aber wieso? 'Warten' verwandelt einen asynchronen Anruf explizit in einen synchronen Anruf, und daher kann der Anrufer nicht asynchron (oder asynchron) sein - zumindest nicht, weil der Anruf bei 'Warten' getätigt wird.

Ja, warte / asynchron war ein großartiges Konzept, aber die Implementierung ist völlig kaputt.

Aus irgendeinem Grund wurde das Schlüsselwort await so implementiert, dass es nur innerhalb einer asynchronen Methode verwendet werden kann. Dies ist in der Tat ein Fehler, obwohl Sie ihn nirgendwo anders als hier sehen werden. Die Lösung für diesen Fehler besteht darin, das Schlüsselwort await so zu implementieren, dass es nur zum Aufrufen einer asynchronen Funktion verwendet werden kann, unabhängig davon, ob die aufrufende Funktion selbst synchron oder asynchron ist.

Aufgrund dieses Fehlers müssen ALLE Ihre Funktionen als asynchron markiert sein und ALLE Ihre Funktionsaufrufe warten verwenden, wenn Sie mit wait eine echte asynchrone Funktion irgendwo in Ihrem Code aufrufen.

Dies bedeutet im Wesentlichen, dass Sie den Overhead von Versprechungen zu allen Funktionen in Ihrer gesamten Anwendung hinzufügen müssen, von denen die meisten nicht asynchron sind und niemals asynchron sein werden.

Wenn Sie tatsächlich darüber nachdenken, sollte für die Verwendung von "Warten" in einer Funktion die Funktion erforderlich sein, die das Schlüsselwort "Warten" enthält, um nicht ASYNC zu sein. Dies liegt daran, dass das Schlüsselwort "Warten" die Verarbeitung in der Funktion unterbricht, in der das Schlüsselwort "Warten" gefunden wird. Wenn die Verarbeitung in dieser Funktion angehalten wird, ist sie definitiv NICHT asynchron.

Also, an die Entwickler von Javascript und ECMAScript - bitte korrigieren Sie die Warten / Async-Implementierung wie folgt ...

• wait kann nur zum Aufrufen von asynchronen Funktionen verwendet werden.
• Warten kann in jeder Art von Funktion erscheinen, synchron oder asynchron.
• Ändern Sie die Fehlermeldung von "Warten ist nur in der asynchronen Funktion gültig" in "Warten kann nur zum Aufrufen von asynchronen Funktionen verwendet werden".