Wie kann ich async / await auf der obersten Ebene verwenden?

Ich habe gehen über wurde async/ awaitund nach über mehrere Artikel gehen, entschied ich mich zu Test Dinge selbst. Ich kann mich jedoch nicht darum kümmern, warum dies nicht funktioniert:

async function main() {  
    var value = await Promise.resolve('Hey there');
    console.log('inside: ' + value);
    return value;
}

var text = main();  
console.log('outside: ' + text);

Die Konsole gibt Folgendes aus (Knoten v8.6.0):

> draußen: [Objekt Versprechen]

> drinnen: Hey da

Warum wird die Protokollnachricht in der Funktion anschließend ausgeführt? Ich dachte, der Grund async/ awaitwurde erstellt, um eine synchrone Ausführung mit asynchronen Aufgaben durchzuführen.

Gibt es eine Möglichkeit, den in der Funktion zurückgegebenen Wert zu verwenden, ohne ein .then()Nachher zu verwenden main()?

Ich kann mich nicht darum kümmern, warum das nicht funktioniert.

Weil mainein Versprechen zurückkommt; Alle asyncFunktionen funktionieren.

Auf der obersten Ebene müssen Sie entweder:

1. Verwenden Sie eine asyncFunktion der obersten Ebene , die niemals ablehnt (es sei denn, Sie möchten "nicht behandelte Ablehnungsfehler") oder

2. Verwenden Sie thenund catch, oder

3. (In Kürze verfügbar!) Verwenden Sie Top-Levelawait , einen Vorschlag, der Stufe 3 des Prozesses erreicht hat und die Verwendung von Top-Level awaitin einem Modul ermöglicht.

# 1 - Top-Level- asyncFunktion, die niemals ablehnt

(async () => {
    try {
        var text = await main();
        console.log(text);
    } catch (e) {
        // Deal with the fact the chain failed
    }
})();

Beachten Sie die catch; Sie müssen mit Versprechungen / asynchronen Ausnahmen umgehen, da sonst nichts passiert. Sie haben keinen Anrufer, an den Sie sie weiterleiten können. Wenn Sie es vorziehen, können Sie dies anhand des Ergebnisses tun, indem Sie es über die catchFunktion (anstelle von try/ catchsyntax) aufrufen :

(async () => {
    var text = await main();
    console.log(text);
})().catch(e => {
    // Deal with the fact the chain failed
});

... was etwas prägnanter ist (ich mag es aus diesem Grund).

Oder behandeln Sie natürlich keine Fehler und lassen Sie einfach den Fehler "Nicht behandelte Ablehnung" zu.

# 2 - thenundcatch

main()
    .then(text => {
        console.log(text);
    })
    .catch(err => {
        // Deal with the fact the chain failed
    });

Der catchHandler wird aufgerufen, wenn Fehler in der Kette oder in Ihrem thenHandler auftreten. (Stellen Sie sicher, dass Ihr catchHandler keine Fehler auslöst, da nichts registriert ist, um diese zu behandeln.)

Oder beide Argumente an then:

main().then(
    text => {
        console.log(text);
    },
    err => {
        // Deal with the fact the chain failed
    }
);

Beachten Sie erneut, dass wir einen Ablehnungshandler registrieren. Stellen Sie in dieser Form jedoch sicher, dass keiner Ihrer thenRückrufe Fehler verursacht und nichts registriert ist, um diese zu behandeln.

# 3 Top-Level awaitin einem Modul

Sie können awaitein Skript, das kein Modul ist, nicht auf der obersten Ebene verwenden. Mit dem awaitVorschlag auf oberster Ebene ( Stufe 3 ) können Sie es jedoch auf der obersten Ebene eines Moduls verwenden. Es ähnelt der Verwendung eines asyncFunktions-Wrappers der obersten Ebene (Nr. 1 oben), da Sie nicht möchten, dass Ihr Code der obersten Ebene zurückgewiesen wird (einen Fehler auslöst), da dies zu einem nicht behandelten Ablehnungsfehler führt. Wenn Sie also nicht diese unbehandelte Ablehnung haben möchten, wenn etwas schief geht, wie bei Nummer 1, möchten Sie Ihren Code in einen Fehlerbehandler einschließen:

// In a module, once the top-level `await` proposal lands
try {
    var text = await main();
    console.log(text);
} catch (e) {
    // Deal with the fact the chain failed
}

Beachten Sie, dass in diesem Fall jedes Modul, das von Ihrem Modul importiert wird, wartet, bis das von Ihnen awaiteingegangene Versprechen erfüllt ist. Wenn ein Modul mit Top-Level awaitbewertet wird, gibt es im Grunde genommen ein Versprechen an den Modullader zurück (wie es eine asyncFunktion tut), der wartet, bis dieses Versprechen erfüllt ist, bevor er die Körper aller Module bewertet, die davon abhängen.

Top-Levelawait ist zu Stufe 3 übergegangen , daher die Antwort auf Ihre Frage. Wie kann ich Async / Warten auf der obersten Ebene verwenden? ist einfach awaitden Anruf hinzuzufügen zu main():

async function main() {  
    var value = await Promise.resolve('Hey there');
    console.log('inside: ' + value);
    return value;
}

var text = await main();  
console.log('outside: ' + text)

Oder nur:

const text = await Promise.resolve('Hey there');
console.log('outside: ' + text)

Denken Sie daran, dass es immer noch nur unter Webpack@v5.0.0-alpha.15 verfügbar ist .

Wenn Sie TypeScript verwenden , ist es in 3.8 gelandet .

v8 hat Unterstützung in Modulen hinzugefügt .

Es wird auch von Deno unterstützt (wie von Gonzalo-Bahamondez kommentiert).

Die eigentliche Lösung für dieses Problem besteht darin, es anders anzugehen.

Wahrscheinlich ist Ihr Ziel eine Art Initialisierung, die normalerweise auf der obersten Ebene einer Anwendung stattfindet.

Die Lösung besteht darin, sicherzustellen, dass sich auf der obersten Ebene Ihrer Anwendung immer nur eine einzige JavaScript-Anweisung befindet. Wenn Sie nur eine Anweisung oben in Ihrer Anwendung haben, können Sie async / await an jedem anderen Punkt überall verwenden (natürlich vorbehaltlich normaler Syntaxregeln).

Anders ausgedrückt: Wickeln Sie Ihre gesamte oberste Ebene in eine Funktion ein, sodass sie nicht mehr die oberste Ebene ist und die Frage löst, wie Async / Wait auf der obersten Ebene einer Anwendung ausgeführt werden soll - das tun Sie nicht.

So sollte die oberste Ebene Ihrer Anwendung aussehen:

import {application} from './server'

application();

Um weitere Informationen zu den aktuellen Antworten zu geben:

Der Inhalt einer node.jsDatei wird derzeit stringartig verkettet, um einen Funktionskörper zu bilden.

Zum Beispiel, wenn Sie eine Datei haben test.js:

// Amazing test file!
console.log('Test!');

Dann node.jswird heimlich eine Funktion verkettet, die aussieht wie:

function(require, __dirname, ... a bunch more top-level properties) {
  // Amazing test file!
  console.log('test!');
}

Das Wichtigste ist, dass die resultierende Funktion KEINE asynchrone Funktion ist. Sie können den Begriff also nicht awaitdirekt darin verwenden!

Angenommen, Sie müssen mit Versprechungen in dieser Datei arbeiten, dann gibt es zwei mögliche Methoden:

1. Nicht await direkt in der Funktion verwenden
2. Nicht benutzen await

Option 1 erfordert, dass wir einen neuen Bereich erstellen (und DIESER Bereich kann es sein async, weil wir die Kontrolle darüber haben):

// Amazing test file!
// Create a new async function (a new scope) and immediately call it!
(async () => {
  await new Promise(...);
  console.log('Test!');
})();

Option 2 erfordert die Verwendung der objektorientierten Versprechen-API (das weniger hübsche, aber ebenso funktionale Paradigma der Arbeit mit Versprechen).

// Amazing test file!
// Create some sort of promise...
let myPromise = new Promise(...);

// Now use the object-oriented API
myPromise.then(() => console.log('Test!'));

Ich persönlich hoffe, dass node.js, wenn es funktioniert, standardmäßig Code zu einer asyncFunktion verkettet . Das würde diese Kopfschmerzen loswerden.

Das Warten auf höchster Ebene ist eine Funktion des kommenden EcmaScript-Standards. Derzeit können Sie es mit TypeScript 3.8 verwenden (derzeit in der RC-Version).

So installieren Sie TypeScript 3.8

Sie können TypeScript 3.8 starten, indem Sie es mit dem folgenden Befehl von npm aus installieren :

$ npm install typescript@rc

Zu diesem Zeitpunkt müssen Sie das rcTag hinzufügen , um die neueste TypScript 3.8-Version zu installieren.

Da es main()asynchron läuft, gibt es ein Versprechen zurück. Sie müssen das Ergebnis in then()Methode erhalten. Und weil auch die then()Rückgabe vielversprechend ist, müssen Sie anrufen process.exit(), um das Programm zu beenden.

main()
   .then(
      (text) => { console.log('outside: ' + text) },
      (err)  => { console.log(err) }
   )
   .then(() => { process.exit() } )