Asynchrone Programmierung in JavaScript: Vollständiger Praxisleitfaden

Asynchrone Programmierung in JavaScript: Von Callbacks bis async/await

JavaScript ist eine Single-Thread-Sprache, aber sein Ausführungsmodell ermöglicht es, tausende gleichzeitige Operationen effizient zu verarbeiten, ohne den Hauptthread zu blockieren. Dies ist dank der asynchronen Programmierung möglich. In Node.js, wo Ein-/Ausgabe-Operationen (Dateilesen, Datenbankabfragen, Netzwerkaufrufe) 90% der Zeit ausmachen, wird das Verständnis von Asynchronität zu einer kritischen Fähigkeit. In diesem Leitfaden werden wir drei Evolutionsstufen der Arbeit mit Asynchronität durchgehen: Callbacks, Promises und async/await, sowie einen Blick unter die Haube des Event Loop werfen.

1. Callbacks: Das Fundament der Asynchronität

Ein Callback ist eine Funktion, die als Argument an eine andere Funktion übergeben und nach Abschluss einer asynchronen Operation aufgerufen wird. Dies ist das älteste und grundlegendste Muster in JavaScript. In Node.js verwenden viele eingebaute Module (fs, http) Callbacks.

Beispiel für das Lesen einer Datei mit einem Callback:

const fs = require('fs');

console.log('Wir beginnen mit dem Lesen der Datei...');

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

console.log('Der Code wird weiter ausgeführt...');

Die Konsolenausgabe zeigt, dass "Der Code wird weiter ausgeführt..." früher erscheint als der Dateiinhalt. Dies ist das nicht-blockierende Verhalten: Der Hauptthread wartet nicht auf den Abschluss des Lesevorgangs, sondern führt die Ausführung fort.

Problem der Callbacks: Callback Hell

Bei verschachtelten asynchronen Operationen wird der Code zu einer "Höllenpyramide":

fs.readFile('user.json', (err, userData) => {  if (err) throw err;  const user = JSON.parse(userData);  db.query(`SELECT * FROM posts WHERE user_id=${user.id}`, (err, posts) => {    if (err) throw err;    fs.writeFile('user_posts.json', JSON.stringify(posts), (err) => {      if (err) throw err;      console.log('Fertig!');    });  });});

Solcher Code ist schwer zu lesen, zu debuggen und zu warten. Die Lösung sind Promises.

2. Promises: Ketten und Fehlerbehandlung

Ein Promise ist ein Objekt, das ein zukünftiges Ergebnis einer asynchronen Operation darstellt. Es kann sich in einem von drei Zuständen befinden: pending (ausstehend), fulfilled (erfolgreich abgeschlossen) oder rejected (mit Fehler abgelehnt).

Erstellen eines einfachen Promises:

const readFilePromise = (filename) => {  return new Promise((resolve, reject) => {    fs.readFile(filename, 'utf8', (err, data) => {      if (err) {        reject(err);      } else {        resolve(data);      }    });  });};

readFilePromise('example.txt')  .then(data => console.log('Daten:', data))  .catch(err => console.error('Fehler:', err));

Promise-Verkettung (Chaining)

Der Hauptvorteil ist die Möglichkeit, sequenzielle Operationen ohne Verschachtelung aufzubauen:

readFilePromise('user.json')  .then(userData => {    const user = JSON.parse(userData);    return dbQueryPromise(`SELECT * FROM posts WHERE user_id=${user.id}`);  })  .then(posts => {    return writeFilePromise('user_posts.json', JSON.stringify(posts));  })  .then(() => console.log('Fertig!'))  .catch(err => console.error('Fehler in der Kette:', err));

Parallele Ausführung: Promise.all

Wenn mehrere unabhängige Operationen gleichzeitig ausgeführt werden müssen:

const promise1 = readFilePromise('file1.txt');const promise2 = readFilePromise('file2.txt');const promise3 = readFilePromise('file3.txt');

Promise.all([promise1, promise2, promise3])  .then(results => {    console.log('Alle Dateien gelesen:', results);  })  .catch(err => console.error('Eines der Promises ist gefallen:', err));

Promise.all wird nur dann erfolgreich abgeschlossen, wenn alle Promises erfolgreich ausgeführt wurden. Wenn mindestens eines fehlschlägt, wird