M

MLOG

Nederlands

Beheers JavaScript's nieuwe Explicit Resource Management met `using` en `await using`. Leer opruimen te automatiseren, resourcelekken te voorkomen en schonere, robuustere code te schrijven.

De Nieuwe Superkracht van JavaScript: Een Diepgaande Blik op Expliciet Resourcebeheer

In de dynamische wereld van softwareontwikkeling is effectief resourcebeheer een hoeksteen van het bouwen van robuuste, betrouwbare en performante applicaties. Decennialang hebben JavaScript-ontwikkelaars vertrouwd op handmatige patronen zoals try...catch...finally om ervoor te zorgen dat kritieke resources — zoals file handles, netwerkverbindingen of databasesessies — correct worden vrijgegeven. Hoewel functioneel, is deze aanpak vaak omslachtig, foutgevoelig en kan hij snel onhandelbaar worden, een patroon dat in complexe scenario's soms de "piramide des onheils" wordt genoemd.

En toen kwam er een paradigmaverschuiving voor de taal: Expliciet Resourcebeheer (ERM). Deze krachtige feature, gefinaliseerd in de ECMAScript 2024 (ES2024) standaard en geïnspireerd door vergelijkbare constructies in talen als C#, Python en Java, introduceert een declaratieve en geautomatiseerde manier om resource-opruiming af te handelen. Door gebruik te maken van de nieuwe sleutelwoorden using en await using, biedt JavaScript nu een veel elegantere en veiligere oplossing voor een tijdloze programmeeruitdaging.

Deze uitgebreide gids neemt je mee op een reis door JavaScript's Expliciet Resourcebeheer. We zullen de problemen die het oplost onderzoeken, de kernconcepten ontleden, praktische voorbeelden doorlopen en geavanceerde patronen ontdekken die je in staat stellen om schonere, veerkrachtigere code te schrijven, waar ter wereld je ook ontwikkelt.

De Oude Garde: De Uitdagingen van Handmatige Resource-opruiming

Voordat we de elegantie van het nieuwe systeem kunnen waarderen, moeten we eerst de pijnpunten van het oude begrijpen. Het klassieke patroon voor resourcebeheer in JavaScript is het try...finally-blok.

De logica is eenvoudig: je verwerft een resource in het try-blok en geeft deze vrij in het finally-blok. Het finally-blok garandeert uitvoering, ongeacht of de code in het try-blok slaagt, faalt of voortijdig wordt beëindigd.

Laten we een veelvoorkomend server-side scenario bekijken: een bestand openen, er wat data naar schrijven en er vervolgens voor zorgen dat het bestand wordt gesloten.

Voorbeeld: Een Eenvoudige Bestandsoperatie met try...finally


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

async function processFile(filePath, data) {
  let fileHandle;
  try {
    console.log('Bestand openen...');
    fileHandle = await fs.open(filePath, 'w');
    console.log('Naar bestand schrijven...');
    await fileHandle.write(data);
    console.log('Data succesvol geschreven.');
  } catch (error) {
    console.error('Er is een fout opgetreden tijdens de bestandsverwerking:', error);
  } finally {
    if (fileHandle) {
      console.log('Bestand sluiten...');
      await fileHandle.close();
    }
  }
}

Deze code werkt, maar legt verschillende zwaktes bloot:

Stel je nu voor dat je meerdere resources beheert, zoals een databaseverbinding en een file handle. De code wordt al snel een geneste puinhoop:


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();
    }
  }
}

Deze nesting is moeilijk te onderhouden en te schalen. Het is een duidelijk signaal dat een betere abstractie nodig is. Dit is precies het probleem waarvoor Expliciet Resourcebeheer is ontworpen.

Een Paradigmaverschuiving: De Principes van Expliciet Resourcebeheer

Expliciet Resourcebeheer (ERM) introduceert een contract tussen een resource-object en de JavaScript-runtime. Het kernidee is simpel: een object kan aangeven hoe het moet worden opgeruimd, en de taal biedt syntaxis om die opruiming automatisch uit te voeren wanneer het object buiten zijn scope valt.

Dit wordt bereikt via twee hoofdcomponenten:

  1. Het 'Disposable Protocol': Een standaardmanier voor objecten om hun eigen opruimlogica te definiëren met behulp van speciale symbolen: Symbol.dispose voor synchrone opruiming en Symbol.asyncDispose voor asynchrone opruiming.
  2. De using en await using Declaraties: Nieuwe sleutelwoorden die een resource binden aan een blok-scope. Wanneer het blok wordt verlaten, wordt de opruimmethode van de resource automatisch aangeroepen.

De Kernconcepten: Symbol.dispose en Symbol.asyncDispose

De kern van ERM wordt gevormd door twee nieuwe, welbekende Symbolen. Een object dat een methode heeft met een van deze symbolen als sleutel, wordt beschouwd als een "disposable resource".

Synchrone Opruiming met Symbol.dispose

Het Symbol.dispose-symbool specificeert een synchrone opruimmethode. Dit is geschikt voor resources waarbij de opruiming geen asynchrone operaties vereist, zoals het synchroon sluiten van een file handle of het vrijgeven van een in-memory lock.

Laten we een wrapper maken voor een tijdelijk bestand dat zichzelf opruimt.


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(`Tijdelijk bestand aangemaakt: ${this.path}`);
  }

  // Dit is de synchrone 'disposable' methode
  [Symbol.dispose]() {
    console.log(`Tijdelijk bestand opruimen: ${this.path}`);
    try {
      fs.unlinkSync(this.path);
      console.log('Bestand succesvol verwijderd.');
    } catch (error) {
      console.error(`Kon bestand niet verwijderen: ${this.path}`, error);
      // Het is belangrijk om fouten ook binnen dispose af te handelen!
    }
  }
}

Elk exemplaar van `TempFile` is nu een 'disposable resource'. Het heeft een methode met als sleutel `Symbol.dispose` die de logica bevat om het bestand van de schijf te verwijderen.

Asynchrone Opruiming met Symbol.asyncDispose

Veel moderne opruimoperaties zijn asynchroon. Het sluiten van een databaseverbinding kan het versturen van een QUIT-commando over het netwerk inhouden, of een message queue-client moet mogelijk zijn uitgaande buffer legen. Voor deze scenario's gebruiken we Symbol.asyncDispose.

De methode die geassocieerd is met Symbol.asyncDispose moet een Promise retourneren (of een async-functie zijn).

Laten we een mock-databaseverbinding modelleren die asynchroon moet worden teruggegeven aan een pool.


// Een mock database pool
const mockDbPool = {
  getConnection: () => {
    console.log('DB-verbinding verkregen.');
    return new MockDbConnection();
  }
};

class MockDbConnection {
  query(sql) {
    console.log(`Query uitvoeren: ${sql}`);
    return Promise.resolve({ success: true, rows: [] });
  }

  // Dit is de asynchrone 'disposable' methode
  async [Symbol.asyncDispose]() {
    console.log('DB-verbinding teruggeven aan de pool...');
    // Simuleer een netwerkvertraging voor het vrijgeven van de verbinding
    await new Promise(resolve => setTimeout(resolve, 50));
    console.log('DB-verbinding vrijgegeven.');
  }
}

Nu is elk exemplaar van `MockDbConnection` een asynchroon 'disposable resource'. Het weet hoe het zichzelf asynchroon moet vrijgeven wanneer het niet langer nodig is.

De Nieuwe Syntaxis: using en await using in Actie

Nu onze 'disposable' klassen zijn gedefinieerd, kunnen we de nieuwe sleutelwoorden gebruiken om ze automatisch te beheren. Deze sleutelwoorden creëren blok-gescoopte declaraties, net als let en const.

Synchrone Opruiming met using

Het using-sleutelwoord wordt gebruikt voor resources die Symbol.dispose implementeren. Wanneer de code-uitvoering het blok verlaat waarin de using-declaratie is gedaan, wordt de [Symbol.dispose]()-methode automatisch aangeroepen.

Laten we onze `TempFile`-klasse gebruiken:


function processDataWithTempFile() {
  console.log('Blok binnengaan...');
  using tempFile = new TempFile('This is some important data.');

  // Je kunt hier met tempFile werken
  const content = fs.readFileSync(tempFile.path, 'utf8');
  console.log(`Gelezen uit tijdelijk bestand: \"${content}\"`);

  // Geen opruimcode hier nodig!
  console.log('...meer werk aan het doen...');
} // <-- tempFile.[Symbol.dispose]() wordt hier automatisch aangeroepen!

processDataWithTempFile();
console.log('Blok is verlaten.');

De uitvoer zou zijn:

Blok binnengaan...
Tijdelijk bestand aangemaakt: /pad/naar/temp_1678886400000.txt
Gelezen uit tijdelijk bestand: "This is some important data."
...meer werk aan het doen...
Tijdelijk bestand opruimen: /pad/naar/temp_1678886400000.txt
Bestand succesvol verwijderd.
Blok is verlaten.

Kijk eens hoe netjes dat is! De volledige levenscyclus van de resource bevindt zich binnen het blok. We declareren het, we gebruiken het en we vergeten het. De taal regelt de opruiming. Dit is een enorme verbetering in leesbaarheid en veiligheid.

Meerdere Resources Beheren

Je kunt meerdere using-declaraties in hetzelfde blok hebben. Ze worden opgeruimd in de omgekeerde volgorde van hun aanmaak (een LIFO- of "stack-achtig" gedrag).


{
  using resourceA = new MyDisposable('A'); // Eerst aangemaakt
  using resourceB = new MyDisposable('B'); // Als tweede aangemaakt
  console.log('Binnen het blok, resources in gebruik...');
} // resourceB wordt eerst opgeruimd, dan resourceA

Asynchrone Opruiming met await using

Het await using-sleutelwoord is de asynchrone tegenhanger van using. Het wordt gebruikt voor resources die Symbol.asyncDispose implementeren. Omdat de opruiming asynchroon is, kan dit sleutelwoord alleen worden gebruikt binnen een async-functie of op het hoogste niveau van een module (als top-level await wordt ondersteund).

Laten we onze `MockDbConnection`-klasse gebruiken:


async function performDatabaseOperation() {
  console.log('Asynchrone functie binnengaan...');
  await using db = mockDbPool.getConnection();

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

  console.log('Databaseoperatie voltooid.');
} // <-- await db.[Symbol.asyncDispose]() wordt hier automatisch aangeroepen!

(async () => {
  await performDatabaseOperation();
  console.log('Asynchrone functie is voltooid.');
})();

De uitvoer demonstreert de asynchrone opruiming:

Asynchrone functie binnengaan...
DB-verbinding verkregen.
Query uitvoeren: SELECT * FROM users
Databaseoperatie voltooid.
DB-verbinding teruggeven aan de pool...
(wacht 50ms)
DB-verbinding vrijgegeven.
Asynchrone functie is voltooid.

Net als bij using, regelt de await using-syntaxis de volledige levenscyclus, maar het wacht correct op het asynchrone opruimproces (awaits). Het kan zelfs resources verwerken die alleen synchroon 'disposable' zijn - het zal er simpelweg niet op wachten.

Geavanceerde Patronen: DisposableStack en AsyncDisposableStack

Soms is de eenvoudige blok-scoping van using niet flexibel genoeg. Wat als je een groep resources moet beheren met een levensduur die niet is gekoppeld aan een enkel lexicaal blok? Of wat als je integreert met een oudere bibliotheek die geen objecten met Symbol.dispose produceert?

Voor deze scenario's biedt JavaScript twee hulpklassen: DisposableStack en AsyncDisposableStack.

DisposableStack: De Flexibele Opruimmanager

Een DisposableStack is een object dat een verzameling opruimoperaties beheert. Het is zelf een 'disposable resource', dus je kunt de volledige levenscyclus ervan beheren met een using-blok.

Het heeft verschillende nuttige methoden:

Voorbeeld: Conditioneel Resourcebeheer

Stel je een functie voor die een logbestand opent alleen als aan een bepaalde voorwaarde is voldaan, maar je wilt dat alle opruiming op één plek aan het einde gebeurt.


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

  const db = stack.use(getDbConnection()); // Gebruik altijd de DB

  if (shouldLog) {
    const logFileStream = fs.createWriteStream('app.log');
    // Stel de opruiming voor de stream uit
    stack.defer(() => {
      console.log('Logbestand-stream sluiten...');
      logFileStream.end();
    });
    db.logTo(logFileStream);
  }

  db.doWork();

} // <-- De stack wordt opgeruimd, waarbij alle geregistreerde opruimfuncties in LIFO-volgorde worden aangeroepen.

AsyncDisposableStack: Voor de Asynchrone Wereld

Zoals je misschien al raadt, is AsyncDisposableStack de asynchrone versie. Het kan zowel synchrone als asynchrone 'disposables' beheren. De primaire opruimmethode is .disposeAsync(), die een Promise retourneert die wordt vervuld wanneer alle asynchrone opruimoperaties zijn voltooid.

Voorbeeld: Een Mix van Resources Beheren

Laten we een request handler voor een webserver maken die een databaseverbinding (asynchrone opruiming) en een tijdelijk bestand (synchrone opruiming) nodig heeft.


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

  // Beheer een asynchroon 'disposable' resource
  const dbConnection = await stack.use(getAsyncDbConnection());

  // Beheer een synchroon 'disposable' resource
  const tempFile = stack.use(new TempFile('request data'));

  // Adopteer een resource van een oude API
  const legacyResource = getLegacyResource();
  stack.adopt(legacyResource, () => legacyResource.shutdown());

  console.log('Verzoek verwerken...');
  await doWork(dbConnection, tempFile.path);

} // <-- stack.disposeAsync() wordt aangeroepen. Het zal de asynchrone opruiming correct afwachten.

De AsyncDisposableStack is een krachtig hulpmiddel voor het orkestreren van complexe setup- en teardown-logica op een schone, voorspelbare manier.

Robuuste Foutafhandeling met SuppressedError

Een van de meest subtiele maar belangrijke verbeteringen van ERM is hoe het met fouten omgaat. Wat gebeurt er als er een fout wordt gegooid binnen het using-blok, en er *nog een* fout wordt gegooid tijdens de daaropvolgende automatische opruiming?

In de oude try...finally-wereld zou de fout uit het finally-blok doorgaans de oorspronkelijke, belangrijkere fout uit het try-blok overschrijven of "onderdrukken". Dit maakte debuggen vaak ongelooflijk moeilijk.

ERM lost dit op met een nieuw globaal fouttype: SuppressedError. Als er een fout optreedt tijdens de opruiming terwijl een andere fout al wordt doorgegeven, wordt de opruimfout "onderdrukt". De oorspronkelijke fout wordt gegooid, maar deze heeft nu een suppressed-eigenschap die de opruimfout bevat.


class FaultyResource {
  [Symbol.dispose]() {
    throw new Error('Fout tijdens opruiming!');
  }
}

try {
  using resource = new FaultyResource();
  throw new Error('Fout tijdens operatie!');
} catch (e) {
  console.log(`Fout opgevangen: ${e.message}`); // Fout tijdens operatie!
  if (e.suppressed) {
    console.log(`Onderdrukte fout: ${e.suppressed.message}`); // Fout tijdens opruiming!
    console.log(e instanceof SuppressedError); // false
    console.log(e.suppressed instanceof Error); // true
  }
}

Dit gedrag zorgt ervoor dat je nooit de context van de oorspronkelijke fout verliest, wat leidt tot veel robuustere en beter te debuggen systemen.

Praktische Toepassingen in het JavaScript Ecosysteem

De toepassingen van Expliciet Resourcebeheer zijn enorm en relevant voor ontwikkelaars over de hele wereld, of ze nu aan de back-end, front-end of in tests werken.

Browser- en Runtime-ondersteuning

Als moderne feature is het belangrijk te weten waar je Expliciet Resourcebeheer kunt gebruiken. Vanaf eind 2023 / begin 2024 is de ondersteuning wijdverbreid in de nieuwste versies van de belangrijkste JavaScript-omgevingen:

Voor oudere omgevingen moet je vertrouwen op transpilers zoals Babel met de juiste plugins om de using-syntaxis te transformeren en de benodigde symbolen en stack-klassen te polyfillen.

Conclusie: Een Nieuw Tijdperk van Veiligheid en Duidelijkheid

JavaScript's Expliciet Resourcebeheer is meer dan alleen syntactische suiker; het is een fundamentele verbetering van de taal die veiligheid, duidelijkheid en onderhoudbaarheid bevordert. Door het vervelende en foutgevoelige proces van resource-opruiming te automatiseren, stelt het ontwikkelaars in staat zich te concentreren op hun primaire bedrijfslogica.

De belangrijkste conclusies zijn:

Wanneer je nieuwe projecten begint of bestaande code refactort, overweeg dan dit krachtige nieuwe patroon te adopteren. Het zal je JavaScript schoner maken, je applicaties betrouwbaarder en je leven als ontwikkelaar net iets gemakkelijker. Het is een werkelijk wereldwijde standaard voor het schrijven van moderne, professionele JavaScript.

JavaScript Explicit Resource Management: De Ultieme Gids voor Geautomatiseerde Opruiming | MLOG