Heute habe ich mit Hilfe von ChatGPT weiter Node.js gelernt und wir haben uns auf die asynchrone Programmierung konzentriert. Dies ist eines der wichtigsten Konzepte in Node.js und ich freue mich, dass ich damit begonnen habe, es zu beherrschen.

Theorie

In Node.js ist die asynchrone Programmierung aufgrund der nicht blockierenden, ereignisgesteuerten Architektur von entscheidender Bedeutung. Dies bedeutet, dass Vorgänge wie das Lesen von Dateien, Datenbankabfragen oder Netzwerkanforderungen nicht die Ausführung anderen Codes blockieren, während auf ein Ergebnis gewartet wird.

Wir haben drei Hauptmethoden zur Handhabung asynchroner Vorgänge untersucht:

1. Rückrufe: Funktionen, die als Argumente an andere Funktionen übergeben werden und ausgeführt werden, sobald ein asynchroner Vorgang abgeschlossen ist.
   

   const fs = require('fs');
   
   fs.readFile('example.txt', 'utf8', (err, data) => {
       if (err) {
           console.error(err);
           return;
       }
       console.log(data);
   });
   

2. Promises: Objekte, die den eventuellen Abschluss (oder Fehler) eines asynchronen Vorgangs und den daraus resultierenden Wert darstellen. Versprechen ermöglichen eine Verkettung und machen den Code im Vergleich zu verschachtelten Rückrufen besser lesbar.
   

   const fs = require('fs').promises;
   
   fs.readFile('example.txt', 'utf8')
       .then(data => {
           console.log(data);
       })
       .catch(err => {
           console.error(err);
       });
   

3. Async/Await: Syntaktischer Zucker, der auf Promises basiert und das synchrone Schreiben von asynchronem Code ermöglicht.
   

   const fs = require('fs').promises;
   
   async function readFile() {
       try {
           const data = await fs.readFile('example.txt', 'utf8');
           console.log(data);
       } catch (err) {
           console.error(err);
       }
   }
   
   readFile();
   

Praktische Aufgabe

Heute habe ich geübt, eine Callback-basierte Funktion in eine Promise-basierte Funktion umzuwandeln.

Originalcode mit Rückrufen:

const fs = require('fs');

function readFileCallback(path, callback) {
    fs.readFile(path, 'utf8', (err, data) => {
        if (err) {
            callback(err);
            return;
        }
        callback(null, data);
    });
}

readFileCallback('example.txt', (err, data) => {
    if (err) {
        console.error(err);
        return;
    }
    console.log(data);
});

Konvertierung in Versprechen:

const fs = require('fs').promises;

function readFilePromise(path) {
    return fs.readFile(path, 'utf8');
}

readFilePromise('example.txt')
    .then(data => {
        console.log(data);
    })
    .catch(err => {
        console.error(err);
    });

Unabhängige Aufgabe

Ich habe auch eine asynchrone Funktion mit async/await geschrieben, die den Inhalt einer Datei liest und ihn in der Konsole protokolliert. Wenn ein Fehler auftritt (z. B. Datei nicht gefunden), sollte es den Fehler abfangen und protokollieren.

const fs = require('fs').promises;

async function readFileAsync(path) {
    try {
        const data = await fs.readFile(path, 'utf8');
        console.log(data);
    } catch (err) {
        console.error(err);
    }
}

readFileAsync('example.txt');

Ressourcen

Alle von ChatGPT erstellten Lektionen finden Sie unter: https://king-tri-ton.github.io/learn-nodejs