M

MLOG

Deutsch

Meistern Sie das neue Explizite Ressourcenmanagement von JavaScript mit `using` und `await using`. Lernen Sie, Bereinigungen zu automatisieren, Ressourcenlecks zu vermeiden und saubereren, robusteren Code zu schreiben.

Die neue Superkraft von JavaScript: Ein tiefer Einblick in das Explizite Ressourcenmanagement

In der dynamischen Welt der Softwareentwicklung ist die effektive Verwaltung von Ressourcen ein Eckpfeiler für die Erstellung robuster, zuverlässiger und performanter Anwendungen. Jahrzehntelang haben sich JavaScript-Entwickler auf manuelle Muster wie try...catch...finally verlassen, um sicherzustellen, dass kritische Ressourcen – wie Datei-Handles, Netzwerkverbindungen oder Datenbanksitzungen – ordnungsgemäß freigegeben werden. Obwohl dieser Ansatz funktional ist, ist er oft langwierig, fehleranfällig und kann schnell unhandlich werden – ein Muster, das in komplexen Szenarien manchmal als "Pyramide des Verderbens" bezeichnet wird.

Hier kommt ein Paradigmenwechsel für die Sprache: Explizites Ressourcenmanagement (ERM). Dieses leistungsstarke Feature, das im ECMAScript 2024 (ES2024)-Standard finalisiert wurde und von ähnlichen Konstrukten in Sprachen wie C#, Python und Java inspiriert ist, führt eine deklarative und automatisierte Methode zur Handhabung der Ressourcenbereinigung ein. Durch die Nutzung der neuen Schlüsselwörter using und await using bietet JavaScript nun eine weitaus elegantere und sicherere Lösung für eine zeitlose Programmierherausforderung.

Dieser umfassende Leitfaden nimmt Sie mit auf eine Reise durch das Explizite Ressourcenmanagement von JavaScript. Wir werden die Probleme untersuchen, die es löst, seine Kernkonzepte analysieren, praktische Beispiele durchgehen und fortgeschrittene Muster aufdecken, die Sie befähigen werden, saubereren und widerstandsfähigeren Code zu schreiben, egal wo auf der Welt Sie entwickeln.

Die alte Garde: Die Herausforderungen der manuellen Ressourcenbereinigung

Bevor wir die Eleganz des neuen Systems würdigen können, müssen wir zuerst die Schmerzpunkte des alten verstehen. Das klassische Muster für das Ressourcenmanagement in JavaScript ist der try...finally-Block.

Die Logik ist einfach: Sie erwerben eine Ressource im try-Block und geben sie im finally-Block frei. Der finally-Block garantiert die Ausführung, unabhängig davon, ob der Code im try-Block erfolgreich ist, fehlschlägt oder vorzeitig zurückkehrt.

Betrachten wir ein gängiges serverseitiges Szenario: eine Datei öffnen, Daten hineinschreiben und dann sicherstellen, dass die Datei geschlossen wird.

Beispiel: Eine einfache Dateioperation mit try...finally


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

async function processFile(filePath, data) {
  let fileHandle;
  try {
    console.log('Öffne Datei...');
    fileHandle = await fs.open(filePath, 'w');
    console.log('Schreibe in Datei...');
    await fileHandle.write(data);
    console.log('Daten erfolgreich geschrieben.');
  } catch (error) {
    console.error('Ein Fehler ist während der Dateiverarbeitung aufgetreten:', error);
  } finally {
    if (fileHandle) {
      console.log('Schließe Datei...');
      await fileHandle.close();
    }
  }
}

Dieser Code funktioniert, aber er zeigt mehrere Schwächen auf:

Stellen Sie sich nun vor, Sie verwalten mehrere Ressourcen, wie eine Datenbankverbindung und ein Datei-Handle. Der Code wird schnell zu einem verschachtelten Durcheinander:


async function logQueryResultToFile(query, filePath) {
  let dbConnection;
  try {
    dbConnection = await getDbConnection();
    const result = await dbConnection.query(query);

    let fileHandle;
    try {
      fileHandle = await fs.open(filePath, 'w');
      await fileHandle.write(JSON.stringify(result));
    } finally {
      if (fileHandle) {
        await fileHandle.close();
      }
    }
  } finally {
    if (dbConnection) {
      await dbConnection.release();
    }
  }
}

Diese Verschachtelung ist schwer zu warten und zu skalieren. Es ist ein klares Signal, dass eine bessere Abstraktion benötigt wird. Genau dieses Problem wurde durch das Explizite Ressourcenmanagement gelöst.

Ein Paradigmenwechsel: Die Prinzipien des Expliziten Ressourcenmanagements

Das Explizite Ressourcenmanagement (ERM) führt einen Vertrag zwischen einem Ressourcenobjekt und der JavaScript-Laufzeitumgebung ein. Die Kernidee ist einfach: Ein Objekt kann deklarieren, wie es bereinigt werden soll, und die Sprache stellt eine Syntax zur Verfügung, um diese Bereinigung automatisch durchzuführen, wenn das Objekt den Gültigkeitsbereich verlässt.

Dies wird durch zwei Hauptkomponenten erreicht:

  1. Das Disposable-Protokoll: Eine standardisierte Methode für Objekte, ihre eigene Bereinigungslogik mithilfe spezieller Symbole zu definieren: Symbol.dispose für die synchrone Bereinigung und Symbol.asyncDispose für die asynchrone Bereinigung.
  2. Die `using`- und `await using`-Deklarationen: Neue Schlüsselwörter, die eine Ressource an einen Block-Gültigkeitsbereich binden. Wenn der Block verlassen wird, wird die Bereinigungsmethode der Ressource automatisch aufgerufen.

Die Kernkonzepte: `Symbol.dispose` und `Symbol.asyncDispose`

Im Zentrum von ERM stehen zwei neue bekannte Symbole. Ein Objekt, das eine Methode mit einem dieser Symbole als Schlüssel hat, wird als "verwerfbare Ressource" (disposable resource) betrachtet.

Synchrone Bereinigung mit `Symbol.dispose`

Das Symbol.dispose-Symbol spezifiziert eine synchrone Bereinigungsmethode. Dies eignet sich für Ressourcen, bei denen die Bereinigung keine asynchronen Operationen erfordert, wie das synchrone Schließen eines Datei-Handles oder das Freigeben einer Sperre im Speicher.

Erstellen wir einen Wrapper für eine temporäre Datei, der sich selbst bereinigt.


const fs = require('fs');
const path = require('path');

class TempFile {
  constructor(content) {
    this.path = path.join(__dirname, `temp_${Date.now()}.txt`);
    fs.writeFileSync(this.path, content);
    console.log(`Temporäre Datei erstellt: ${this.path}`);
  }

  // Dies ist die synchrone Methode zum Verwerfen
  [Symbol.dispose]() {
    console.log(`Verwerfe temporäre Datei: ${this.path}`);
    try {
      fs.unlinkSync(this.path);
      console.log('Datei erfolgreich gelöscht.');
    } catch (error) {
      console.error(`Fehler beim Löschen der Datei: ${this.path}`, error);
      // Es ist wichtig, Fehler auch innerhalb von dispose zu behandeln!
    }
  }
}

Jede Instanz von `TempFile` ist nun eine verwerfbare Ressource. Sie hat eine Methode, die durch `Symbol.dispose` gekapselt ist und die Logik zum Löschen der Datei von der Festplatte enthält.

Asynchrone Bereinigung mit `Symbol.asyncDispose`

Viele moderne Bereinigungsoperationen sind asynchron. Das Schließen einer Datenbankverbindung kann das Senden eines `QUIT`-Befehls über das Netzwerk beinhalten, oder ein Message-Queue-Client muss möglicherweise seinen ausgehenden Puffer leeren. Für diese Szenarien verwenden wir `Symbol.asyncDispose`.

Die mit `Symbol.asyncDispose` verknüpfte Methode muss ein `Promise` zurückgeben (oder eine `async`-Funktion sein).

Modellieren wir eine simulierte Datenbankverbindung, die asynchron an einen Pool zurückgegeben werden muss.


// Ein simulierter Datenbank-Pool
const mockDbPool = {
  getConnection: () => {
    console.log('DB-Verbindung hergestellt.');
    return new MockDbConnection();
  }
};

class MockDbConnection {
  query(sql) {
    console.log(`Führe Abfrage aus: ${sql}`);
    return Promise.resolve({ success: true, rows: [] });
  }

  // Dies ist die asynchrone Methode zum Verwerfen
  async [Symbol.asyncDispose]() {
    console.log('Gebe DB-Verbindung an den Pool zurück...');
    // Simuliert eine Netzwerkverzögerung beim Freigeben der Verbindung
    await new Promise(resolve => setTimeout(resolve, 50));
    console.log('DB-Verbindung freigegeben.');
  }
}

Jetzt ist jede `MockDbConnection`-Instanz eine asynchron verwerfbare Ressource. Sie weiß, wie sie sich asynchron selbst freigeben kann, wenn sie nicht mehr benötigt wird.

Die neue Syntax: `using` und `await using` in Aktion

Nachdem unsere verwerfbaren Klassen definiert sind, können wir nun die neuen Schlüsselwörter verwenden, um sie automatisch zu verwalten. Diese Schlüsselwörter erstellen block-gültige Deklarationen, genau wie `let` und `const`.

Synchrone Bereinigung mit `using`

Das Schlüsselwort `using` wird für Ressourcen verwendet, die `Symbol.dispose` implementieren. Wenn die Codeausführung den Block verlässt, in dem die `using`-Deklaration gemacht wurde, wird die `[Symbol.dispose]()`-Methode automatisch aufgerufen.

Verwenden wir unsere `TempFile`-Klasse:


function processDataWithTempFile() {
  console.log('Betrete Block...');
  using tempFile = new TempFile('Dies sind einige wichtige Daten.');

  // Hier können Sie mit tempFile arbeiten
  const content = fs.readFileSync(tempFile.path, 'utf8');
  console.log(`Gelesen aus temporärer Datei: \"${content}\".`);

  // Kein Bereinigungscode hier erforderlich!
  console.log('...weitere Arbeit wird erledigt...');
} // <-- tempFile.[Symbol.dispose]() wird genau hier automatisch aufgerufen!

processDataWithTempFile();
console.log('Block wurde verlassen.');

Die Ausgabe wäre:

Betrete Block...
Temporäre Datei erstellt: /path/to/temp_1678886400000.txt
Gelesen aus temporärer Datei: "Dies sind einige wichtige Daten."
...weitere Arbeit wird erledigt...
Verwerfe temporäre Datei: /path/to/temp_1678886400000.txt
Datei erfolgreich gelöscht.
Block wurde verlassen.

Schauen Sie, wie sauber das ist! Der gesamte Lebenszyklus der Ressource ist innerhalb des Blocks enthalten. Wir deklarieren sie, wir verwenden sie und wir vergessen sie. Die Sprache übernimmt die Bereinigung. Dies ist eine massive Verbesserung der Lesbarkeit und Sicherheit.

Verwaltung mehrerer Ressourcen

Sie können mehrere `using`-Deklarationen im selben Block haben. Sie werden in umgekehrter Reihenfolge ihrer Erstellung entsorgt (ein LIFO- oder "Stack-ähnliches" Verhalten).


{
  using resourceA = new MyDisposable('A'); // Zuerst erstellt
  using resourceB = new MyDisposable('B'); // Zweitens erstellt
  console.log('Innerhalb des Blocks, Ressourcen werden verwendet...');
} // resourceB wird zuerst verworfen, dann resourceA

Asynchrone Bereinigung mit `await using`

Das Schlüsselwort `await using` ist das asynchrone Gegenstück zu `using`. Es wird für Ressourcen verwendet, die `Symbol.asyncDispose` implementieren. Da die Bereinigung asynchron ist, kann dieses Schlüsselwort nur innerhalb einer `async`-Funktion oder auf der obersten Ebene eines Moduls verwendet werden (sofern Top-Level-Await unterstützt wird).

Verwenden wir unsere `MockDbConnection`-Klasse:


async function performDatabaseOperation() {
  console.log('Betrete asynchrone Funktion...');
  await using db = mockDbPool.getConnection();

  await db.query('SELECT * FROM users');

  console.log('Datenbankoperation abgeschlossen.');
} // <-- await db.[Symbol.asyncDispose]() wird hier automatisch aufgerufen!

(async () => {
  await performDatabaseOperation();
  console.log('Asynchrone Funktion wurde abgeschlossen.');
})();

Die Ausgabe demonstriert die asynchrone Bereinigung:

Betrete asynchrone Funktion...
DB-Verbindung hergestellt.
Führe Abfrage aus: SELECT * FROM users
Datenbankoperation abgeschlossen.
Gebe DB-Verbindung an den Pool zurück...
(wartet 50ms)
DB-Verbindung freigegeben.
Asynchrone Funktion wurde abgeschlossen.

Genau wie bei `using` handhabt die `await using`-Syntax den gesamten Lebenszyklus, aber sie wartet korrekt auf den asynchronen Bereinigungsprozess. Sie kann sogar Ressourcen handhaben, die nur synchron entsorgt werden können – sie wird einfach nicht auf sie warten.

Fortgeschrittene Muster: `DisposableStack` und `AsyncDisposableStack`

Manchmal ist das einfache Block-Scoping von `using` nicht flexibel genug. Was ist, wenn Sie eine Gruppe von Ressourcen verwalten müssen, deren Lebensdauer nicht an einen einzelnen lexikalischen Block gebunden ist? Oder was ist, wenn Sie eine ältere Bibliothek integrieren, die keine Objekte mit `Symbol.dispose` erzeugt?

Für diese Szenarien bietet JavaScript zwei Hilfsklassen: `DisposableStack` und `AsyncDisposableStack`.

`DisposableStack`: Der flexible Bereinigungs-Manager

Ein `DisposableStack` ist ein Objekt, das eine Sammlung von Bereinigungsoperationen verwaltet. Es ist selbst eine verwerfbare Ressource, sodass Sie seine gesamte Lebensdauer mit einem `using`-Block verwalten können.

Es hat mehrere nützliche Methoden:

Beispiel: Bedingtes Ressourcenmanagement

Stellen Sie sich eine Funktion vor, die eine Protokolldatei nur öffnet, wenn eine bestimmte Bedingung erfüllt ist, aber Sie möchten, dass die gesamte Bereinigung an einem Ort am Ende stattfindet.


function processWithConditionalLogging(shouldLog) {
  using stack = new DisposableStack();

  const db = stack.use(getDbConnection()); // Die DB immer verwenden

  if (shouldLog) {
    const logFileStream = fs.createWriteStream('app.log');
    // Die Bereinigung für den Stream aufschieben
    stack.defer(() => {
      console.log('Schließe Protokolldatei-Stream...');
      logFileStream.end();
    });
    db.logTo(logFileStream);
  }

  db.doWork();

} // <-- Der Stack wird verworfen und ruft alle registrierten Bereinigungsfunktionen in LIFO-Reihenfolge auf.

`AsyncDisposableStack`: Für die asynchrone Welt

Wie Sie vielleicht vermuten, ist `AsyncDisposableStack` die asynchrone Version. Sie kann sowohl synchrone als auch asynchrone verwerfbare Ressourcen verwalten. Ihre primäre Bereinigungsmethode ist `.disposeAsync()`, die ein `Promise` zurückgibt, das aufgelöst wird, wenn alle asynchronen Bereinigungsoperationen abgeschlossen sind.

Beispiel: Verwaltung einer Mischung von Ressourcen

Erstellen wir einen Webserver-Anfrage-Handler, der eine Datenbankverbindung (asynchrone Bereinigung) und eine temporäre Datei (synchrone Bereinigung) benötigt.


async function handleRequest() {
  await using stack = new AsyncDisposableStack();

  // Eine asynchron verwerfbare Ressource verwalten
  const dbConnection = await stack.use(getAsyncDbConnection());

  // Eine synchron verwerfbare Ressource verwalten
  const tempFile = stack.use(new TempFile('Anfragedaten'));

  // Eine Ressource von einer alten API übernehmen
  const legacyResource = getLegacyResource();
  stack.adopt(legacyResource, () => legacyResource.shutdown());

  console.log('Verarbeite Anfrage...');
  await doWork(dbConnection, tempFile.path);

} // <-- stack.disposeAsync() wird aufgerufen. Es wird die asynchrone Bereinigung korrekt abwarten.

Der `AsyncDisposableStack` ist ein leistungsstarkes Werkzeug zur Orchestrierung komplexer Einrichtungs- und Abbau-Logik auf saubere, vorhersagbare Weise.

Robuste Fehlerbehandlung mit `SuppressedError`

Eine der subtilsten, aber bedeutendsten Verbesserungen von ERM ist, wie es Fehler behandelt. Was passiert, wenn ein Fehler innerhalb des `using`-Blocks ausgelöst wird und *ein weiterer* Fehler während der anschließenden automatischen Entsorgung ausgelöst wird?

In der alten Welt von `try...finally` würde der Fehler aus dem `finally`-Block typischerweise den ursprünglichen, wichtigeren Fehler aus dem `try`-Block überschreiben oder "unterdrücken". Dies machte das Debuggen oft unglaublich schwierig.

ERM löst dieses Problem mit einem neuen globalen Fehlertyp: `SuppressedError`. Wenn während der Entsorgung ein Fehler auftritt, während bereits ein anderer Fehler propagiert wird, wird der Entsorgungsfehler "unterdrückt". Der ursprüngliche Fehler wird ausgelöst, aber er hat jetzt eine `suppressed`-Eigenschaft, die den Entsorgungsfehler enthält.


class FaultyResource {
  [Symbol.dispose]() {
    throw new Error('Fehler beim Verwerfen!');
  }
}

try {
  using resource = new FaultyResource();
  throw new Error('Fehler während der Operation!');
} catch (e) {
  console.log(`Fehler abgefangen: ${e.message}`); // Fehler während der Operation!
  if (e.suppressed) {
    console.log(`Unterdrückter Fehler: ${e.suppressed.message}`); // Fehler beim Verwerfen!
    console.log(e instanceof SuppressedError); // false
    console.log(e.suppressed instanceof Error); // true
  }
}

Dieses Verhalten stellt sicher, dass Sie nie den Kontext des ursprünglichen Fehlers verlieren, was zu wesentlich robusteren und besser debugbaren Systemen führt.

Praktische Anwendungsfälle im gesamten JavaScript-Ökosystem

Die Anwendungen des Expliziten Ressourcenmanagements sind vielfältig und für Entwickler auf der ganzen Welt relevant, egal ob sie im Backend, Frontend oder im Testbereich arbeiten.

Browser- und Laufzeitunterstützung

Als modernes Feature ist es wichtig zu wissen, wo Sie das Explizite Ressourcenmanagement verwenden können. Stand Ende 2023 / Anfang 2024 ist die Unterstützung in den neuesten Versionen der wichtigsten JavaScript-Umgebungen weit verbreitet:

Für ältere Umgebungen müssen Sie auf Transpiler wie Babel mit den entsprechenden Plugins zurückgreifen, um die `using`-Syntax zu transformieren und die erforderlichen Symbole und Stack-Klassen zu polyfillen.

Fazit: Eine neue Ära der Sicherheit und Klarheit

Das Explizite Ressourcenmanagement von JavaScript ist mehr als nur syntaktischer Zucker; es ist eine grundlegende Verbesserung der Sprache, die Sicherheit, Klarheit und Wartbarkeit fördert. Indem es den mühsamen und fehleranfälligen Prozess der Ressourcenbereinigung automatisiert, ermöglicht es Entwicklern, sich auf ihre primäre Geschäftslogik zu konzentrieren.

Die wichtigsten Erkenntnisse sind:

Wenn Sie neue Projekte beginnen oder bestehenden Code refaktorisieren, ziehen Sie die Übernahme dieses leistungsstarken neuen Musters in Betracht. Es wird Ihren JavaScript-Code sauberer, Ihre Anwendungen zuverlässiger und Ihr Leben als Entwickler ein kleines bisschen einfacher machen. Es ist ein wahrhaft globaler Standard für das Schreiben von modernem, professionellem JavaScript.

JavaScript Explizites Ressourcenmanagement: Der ultimative Leitfaden zur Automatisierung der Bereinigung | MLOG