Async und Await

Teil des Abschnitts Node.js-Grundlagen der Node.js-Journey von Coddy. Lektion 23 von 33.

Eine Kette von Aufrufen mit .then liest sich anders, als du über die Schritte nachdenkst: lesen, dann parsen, dann speichern.

Innerhalb einer async-Funktion pausiert await, bis ein Promise abgeschlossen ist, und liefert dir seinen Wert. Ein fehlgeschlagenes Promise löst dort einen Fehler aus, daher behandeln try und catch ihn. In einem Modul funktioniert await auch auf der obersten Ebene.

import { readFile } from 'node:fs/promises';

const loadConfig = async () => {
    try {
        return JSON.parse(await readFile('config.json', 'utf8'));
    } catch {
        return {};
    }
};

const config = await loadConfig();
console.log(config.port ?? 3000);

Eine async-Funktion gibt immer ein Promise zurück, daher muss auch ihr Aufrufer darauf warten. Vergisst du ein await, erhältst du statt des Werts das Promise selbst: Promise { <pending> }.

Aufgabe

Einfach

In diesem Schritt wird das vorbereitete Projekt des Kurses für ein Notizen-Befehlszeilentool geöffnet, nicht deine Projektdateien aus Promises (einschließlich count.js). Deine frühere Arbeit bleibt in ihrer eigenen Lektion. Lies die bereitgestellten Dateien, bevor du store.js bearbeitest. Diese Kopie enthält den promise-basierten Notizenleser und seine Fehlerbehandlung.

store.js verwendet jetzt die Promise-Versionen von readFile und writeFile, und seine Methoden sind async. Aber noch wartet nichts auf die Promises, deshalb schlägt jeder Befehl fehl. Füge überall dort await hinzu, wo ein Promise abgeschlossen sein muss, bevor der nächste Schritt ausgeführt wird.

Warte in store.js in load auf readFile, bevor JSON.parse den Text verwendet.
In store.js ist load async und gibt daher ein Promise zurück. Warte darauf, wenn der Store notes festlegt. Ein Modul kann await auf der obersten Ebene außerhalb jeder Funktion verwenden.
Warte in store.js in save auf writeFile und in add und remove auf this.save().
In notes.js sind store.add und store.remove jetzt async. Warte in den Zweigen add und done auf sie, damit n und removed Werte statt Promises enthalten.

Damit gibt es insgesamt sieben awaits. Danach funktioniert jeder Befehl wie zuvor. list zeigt die Notizen in notes.json an. Bei den beiden anfänglichen Notizen gibt add Buy bread Saved note 3. aus, und done 1 gibt danach Done: Buy milk aus.

Probier es aus: Gib list in das Feld nach $ node notes.js ein, bevor du etwas änderst. Du siehst notes.json is damaged: ..., aber die Datei ist in Ordnung: JSON.parse wurde statt des Dateitexts ein Promise übergeben. Nach deinen Änderungen zeigt list die Notizen wieder an. Gib dann add Buy bread ein und sieh dir Saved note 3. an. Gib done 1 ein und sieh dir Done: Buy milk an.

Probier es selbst

import { existsSync } from 'node:fs';
import { readFile, writeFile } from 'node:fs/promises';

const file = 'notes.json';

// readFile und writeFile geben jetzt Promises zurück. Warte mit await auf jedes einzelne.
const load = async () => {
    if (!existsSync(file)) {
        return [];
    }
    try {
        return JSON.parse(readFile(file, 'utf8'));
    } catch (err) {
        console.error(`notes.json is damaged: ${err.message}`);
        process.exit(1);
    }
};

const store = {
    notes: load(),
    async save() {
        writeFile(file, JSON.stringify(this.notes, null, 2));
    },
    async add(text) {
        this.notes.push(text);
        this.save();
        return this.notes.length;
    },
    async remove(n) {
        const [text] = this.notes.splice(n - 1, 1);
        this.save();
        return text;
    },
};

export default store;