M

MLOG

Čeština

Ovládněte novou Explicitní správu zdrojů v JavaScriptu s `using` a `await using`. Naučte se automatizovat čištění, předcházet únikům zdrojů a psát čistší a robustnější kód.

Nová superschopnost JavaScriptu: Hloubkový pohled na explicitní správu zdrojů

V dynamickém světě vývoje softwaru je efektivní správa zdrojů základním kamenem pro tvorbu robustních, spolehlivých a výkonných aplikací. Po desetiletí se vývojáři v JavaScriptu spoléhali na manuální vzory jako try...catch...finally, aby zajistili, že kritické zdroje – jako jsou souborové handly, síťová připojení nebo databázové relace – budou správně uvolněny. Ačkoli je tento přístup funkční, je často příliš upovídaný, náchylný k chybám a může se rychle stát těžkopádným, což je vzor, který se v komplexních scénářích někdy označuje jako „pyramida zkázy“.

A nyní přichází změna paradigmatu pro tento jazyk: Explicitní správa zdrojů (ERM). Tato mocná funkce, finalizovaná ve standardu ECMAScript 2024 (ES2024) a inspirovaná podobnými konstrukcemi v jazycích jako C#, Python a Java, představuje deklarativní a automatizovaný způsob, jak se vypořádat s čištěním zdrojů. Využitím nových klíčových slov using a await using nyní JavaScript poskytuje mnohem elegantnější a bezpečnější řešení pro nadčasovou programátorskou výzvu.

Tento komplexní průvodce vás provede světem Explicitní správy zdrojů v JavaScriptu. Prozkoumáme problémy, které řeší, rozebereme její klíčové koncepty, projdeme si praktické příklady a odhalíme pokročilé vzory, které vám umožní psát čistší a odolnější kód, bez ohledu na to, kde na světě vyvíjíte.

Stará garda: Výzvy ručního čištění zdrojů

Než budeme moci ocenit eleganci nového systému, musíme nejprve pochopit problematická místa toho starého. Klasickým vzorem pro správu zdrojů v JavaScriptu je blok try...finally.

Logika je jednoduchá: získáte zdroj v bloku try a uvolníte ho v bloku finally. Blok finally zaručuje provedení, ať už kód v bloku try uspěje, selže, nebo se předčasně ukončí příkazem return.

Uvažujme běžný serverový scénář: otevření souboru, zápis dat do něj a následné zajištění, že soubor bude uzavřen.

Příklad: Jednoduchá operace se souborem pomocí try...finally


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

async function processFile(filePath, data) {
  let fileHandle;
  try {
    console.log('Otevírám soubor...');
    fileHandle = await fs.open(filePath, 'w');
    console.log('Zapisuji do souboru...');
    await fileHandle.write(data);
    console.log('Data úspěšně zapsána.');
  } catch (error) {
    console.error('Během zpracování souboru došlo k chybě:', error);
  } finally {
    if (fileHandle) {
      console.log('Zavírám soubor...');
      await fileHandle.close();
    }
  }
}

Tento kód funguje, ale odhaluje několik slabin:

Nyní si představte správu více zdrojů, jako je databázové připojení a souborový handle. Kód se rychle stává vnořeným zmatkem:


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

Toto vnořování je obtížné na údržbu a škálování. Je to jasný signál, že je zapotřebí lepší abstrakce. A přesně tento problém byla Explicitní správa zdrojů navržena, aby vyřešila.

Změna paradigmatu: Principy explicitní správy zdrojů

Explicitní správa zdrojů (ERM) zavádí kontrakt mezi objektem zdroje a běhovým prostředím JavaScriptu. Základní myšlenka je jednoduchá: objekt může deklarovat, jak by měl být uvolněn, a jazyk poskytuje syntaxi pro automatické provedení tohoto uvolnění, když objekt opustí svůj rozsah platnosti (scope).

Toho je dosaženo pomocí dvou hlavních komponent:

  1. Protokol "Disposable": Standardní způsob, jak mohou objekty definovat svou vlastní logiku pro čištění pomocí speciálních symbolů: Symbol.dispose pro synchronní čištění a Symbol.asyncDispose pro asynchronní čištění.
  2. Deklarace using a await using: Nová klíčová slova, která vážou zdroj na blokový rozsah platnosti. Když je blok opuštěn, metoda pro čištění zdroje je automaticky zavolána.

Klíčové koncepty: Symbol.dispose a Symbol.asyncDispose

V srdci ERM jsou dva nové dobře známé symboly. Objekt, který má metodu s jedním z těchto symbolů jako klíč, je považován za „uvolnitelný zdroj“ (disposable resource).

Synchronní uvolnění pomocí Symbol.dispose

Symbol Symbol.dispose specifikuje synchronní metodu pro čištění. To je vhodné pro zdroje, kde čištění nevyžaduje žádné asynchronní operace, jako je synchronní uzavření souborového handlu nebo uvolnění zámku v paměti.

Vytvořme si obalující třídu pro dočasný soubor, který se sám po sobě uklidí.


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(`Vytvořen dočasný soubor: ${this.path}`);
  }

  // Toto je synchronní metoda pro uvolnění
  [Symbol.dispose]() {
    console.log(`Uvolňuji dočasný soubor: ${this.path}`);
    try {
      fs.unlinkSync(this.path);
      console.log('Soubor úspěšně smazán.');
    } catch (error) {
      console.error(`Nepodařilo se smazat soubor: ${this.path}`, error);
      // Je důležité ošetřovat chyby i uvnitř metody dispose!
    }
  }
}

Jakákoli instance `TempFile` je nyní uvolnitelným zdrojem. Má metodu klíčovanou symbolem `Symbol.dispose`, která obsahuje logiku pro smazání souboru z disku.

Asynchronní uvolnění pomocí Symbol.asyncDispose

Mnoho moderních operací čištění je asynchronních. Uzavření databázového připojení může zahrnovat odeslání příkazu QUIT po síti, nebo klient pro frontu zpráv může potřebovat vyprázdnit svůj odchozí buffer. Pro tyto scénáře používáme Symbol.asyncDispose.

Metoda spojená se symbolem Symbol.asyncDispose musí vracet Promise (nebo být async funkcí).

Namodelujme si fiktivní databázové připojení, které je třeba asynchronně vrátit zpět do poolu.


// Fiktivní databázový pool
const mockDbPool = {
  getConnection: () => {
    console.log('Databázové připojení získáno.');
    return new MockDbConnection();
  }
};

class MockDbConnection {
  query(sql) {
    console.log(`Provádím dotaz: ${sql}`);
    return Promise.resolve({ success: true, rows: [] });
  }

  // Toto je asynchronní metoda pro uvolnění
  async [Symbol.asyncDispose]() {
    console.log('Uvolňuji databázové připojení zpět do poolu...');
    // Simulace síťového zpoždění pro uvolnění připojení
    await new Promise(resolve => setTimeout(resolve, 50));
    console.log('Databázové připojení uvolněno.');
  }
}

Nyní je jakákoli instance `MockDbConnection` asynchronně uvolnitelným zdrojem. Ví, jak se asynchronně uvolnit, když už není potřeba.

Nová syntaxe: using a await using v akci

S našimi definovanými uvolnitelnými třídami nyní můžeme použít nová klíčová slova k jejich automatické správě. Tato klíčová slova vytvářejí deklarace s blokovým rozsahem platnosti, stejně jako let a const.

Synchronní čištění s using

Klíčové slovo using se používá pro zdroje, které implementují Symbol.dispose. Když provádění kódu opustí blok, ve kterém byla deklarace using provedena, metoda [Symbol.dispose]() je automaticky zavolána.

Použijme naši třídu `TempFile`:


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

  // Zde můžete pracovat s tempFile
  const content = fs.readFileSync(tempFile.path, 'utf8');
  console.log(`Přečteno z dočasného souboru: "${content}"`);

  // Zde není potřeba žádný kód pro čištění!
  console.log('...provádím další práci...');
} // <-- tempFile.[Symbol.dispose]() je automaticky zavolána právě zde!

processDataWithTempFile();
console.log('Blok byl opuštěn.');

Výstup by byl:

Vstupuji do bloku...
Vytvořen dočasný soubor: /path/to/temp_1678886400000.txt
Přečteno z dočasného souboru: "This is some important data."
...provádím další práci...
Uvolňuji dočasný soubor: /path/to/temp_1678886400000.txt
Soubor úspěšně smazán.
Blok byl opuštěn.

Podívejte se, jak čisté to je! Celý životní cyklus zdroje je obsažen v bloku. Deklarujeme ho, použijeme ho a zapomeneme na něj. Jazyk se postará o čištění. To je obrovské zlepšení v čitelnosti a bezpečnosti.

Správa více zdrojů

V jednom bloku můžete mít více deklarací using. Budou uvolněny v opačném pořadí, než v jakém byly vytvořeny (chování LIFO neboli „zásobníkové“).


{
  using resourceA = new MyDisposable('A'); // Vytvořen jako první
  using resourceB = new MyDisposable('B'); // Vytvořen jako druhý
  console.log('Uvnitř bloku, používám zdroje...');
} // resourceB je uvolněn jako první, poté resourceA

Asynchronní čištění s await using

Klíčové slovo await using je asynchronním protějškem using. Používá se pro zdroje, které implementují Symbol.asyncDispose. Jelikož je čištění asynchronní, toto klíčové slovo lze použít pouze uvnitř async funkce nebo na nejvyšší úrovni modulu (pokud je podporován top-level await).

Použijme naši třídu `MockDbConnection`:


async function performDatabaseOperation() {
  console.log('Vstupuji do asynchronní funkce...');
  await using db = mockDbPool.getConnection();

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

  console.log('Operace s databází dokončena.');
} // <-- await db.[Symbol.asyncDispose]() je automaticky zavolána zde!

(async () => {
  await performDatabaseOperation();
  console.log('Asynchronní funkce byla dokončena.');
})();

Výstup demonstruje asynchronní čištění:

Vstupuji do asynchronní funkce...
Databázové připojení získáno.
Provádím dotaz: SELECT * FROM users
Operace s databází dokončena.
Uvolňuji databázové připojení zpět do poolu...
(čeká 50 ms)
Databázové připojení uvolněno.
Asynchronní funkce byla dokončena.

Stejně jako u using, syntaxe await using se stará o celý životní cyklus, ale správně čeká (awaits) na dokončení asynchronního procesu čištění. Dokáže dokonce zpracovat zdroje, které jsou pouze synchronně uvolnitelné – jednoduše na ně nebude čekat.

Pokročilé vzory: DisposableStack a AsyncDisposableStack

Někdy jednoduchý blokový rozsah platnosti using není dostatečně flexibilní. Co když potřebujete spravovat skupinu zdrojů s životností, která není vázána na jediný lexikální blok? Nebo co když integrujete se starší knihovnou, která neprodukuje objekty se Symbol.dispose?

Pro tyto scénáře JavaScript poskytuje dvě pomocné třídy: DisposableStack a AsyncDisposableStack.

DisposableStack: Flexibilní správce čištění

DisposableStack je objekt, který spravuje kolekci operací čištění. Sám o sobě je uvolnitelným zdrojem, takže jeho celý životní cyklus můžete spravovat pomocí bloku using.

Má několik užitečných metod:

Příklad: Podmíněná správa zdrojů

Představte si funkci, která otevírá logovací soubor pouze pokud je splněna určitá podmínka, ale chcete, aby se veškeré čištění odehrálo na jednom místě na konci.


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

  const db = stack.use(getDbConnection()); // Vždy použít DB

  if (shouldLog) {
    const logFileStream = fs.createWriteStream('app.log');
    // Odložit čištění pro stream
    stack.defer(() => {
      console.log('Zavírám stream logovacího souboru...');
      logFileStream.end();
    });
    db.logTo(logFileStream);
  }

  db.doWork();

} // <-- Zásobník je uvolněn, volají se všechny registrované funkce pro čištění v pořadí LIFO.

AsyncDisposableStack: Pro asynchronní svět

Jak asi tušíte, AsyncDisposableStack je asynchronní verze. Může spravovat jak synchronní, tak asynchronní uvolnitelné zdroje. Její primární metodou pro čištění je .disposeAsync(), která vrací Promise, jež se vyřeší, když jsou všechny asynchronní operace čištění dokončeny.

Příklad: Správa směsi zdrojů

Vytvořme obslužný program pro požadavek webového serveru, který potřebuje databázové připojení (asynchronní čištění) a dočasný soubor (synchronní čištění).


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

  // Správa asynchronního uvolnitelného zdroje
  const dbConnection = await stack.use(getAsyncDbConnection());

  // Správa synchronního uvolnitelného zdroje
  const tempFile = stack.use(new TempFile('request data'));

  // Převzetí zdroje ze starého API
  const legacyResource = getLegacyResource();
  stack.adopt(legacyResource, () => legacyResource.shutdown());

  console.log('Zpracovávám požadavek...');
  await doWork(dbConnection, tempFile.path);

} // <-- je zavolána metoda stack.disposeAsync(). Správně počká na dokončení asynchronního čištění.

AsyncDisposableStack je mocný nástroj pro orchestraci složité logiky přípravy a úklidu čistým a předvídatelným způsobem.

Robustní zpracování chyb s SuppressedError

Jedním z nejjemnějších, ale nejvýznamnějších vylepšení ERM je způsob, jakým zpracovává chyby. Co se stane, pokud je vyhozena chyba uvnitř bloku using a *další* chyba je vyhozena během následného automatického uvolňování?

Ve starém světě try...finally by chyba z bloku finally obvykle přepsala nebo „potlačila“ původní, důležitější chybu z bloku try. To často neuvěřitelně ztěžovalo ladění.

ERM toto řeší novým globálním typem chyby: `SuppressedError`. Pokud dojde k chybě během uvolňování, zatímco se již šíří jiná chyba, chyba při uvolňování je „potlačena“. Původní chyba je vyhozena, ale nyní má vlastnost suppressed, která obsahuje chybu při uvolňování.


class FaultyResource {
  [Symbol.dispose]() {
    throw new Error('Chyba během uvolňování!');
  }
}

try {
  using resource = new FaultyResource();
  throw new Error('Chyba během operace!');
} catch (e) {
  console.log(`Zachytena chyba: ${e.message}`); // Chyba během operace!
  if (e.suppressed) {
    console.log(`Potlačená chyba: ${e.suppressed.message}`); // Chyba během uvolňování!
    console.log(e instanceof SuppressedError); // false
    console.log(e.suppressed instanceof Error); // true
  }
}

Toto chování zajišťuje, že nikdy neztratíte kontext původního selhání, což vede k mnohem robustnějším a lépe laditelným systémům.

Praktické případy použití napříč ekosystémem JavaScriptu

Aplikace Explicitní správy zdrojů jsou rozsáhlé a relevantní pro vývojáře po celém světě, ať už pracují na back-endu, front-endu nebo v oblasti testování.

Podpora v prohlížečích a běhových prostředích

Jelikož se jedná o moderní funkci, je důležité vědět, kde můžete Explicitní správu zdrojů použít. Ke konci roku 2023 / začátku roku 2024 je podpora rozšířená v nejnovějších verzích hlavních JavaScriptových prostředí:

Pro starší prostředí se budete muset spolehnout na transpilační nástroje jako Babel s příslušnými pluginy pro transformaci syntaxe using a polyfill pro potřebné symboly a třídy zásobníků.

Závěr: Nová éra bezpečnosti a srozumitelnosti

Explicitní správa zdrojů v JavaScriptu je více než jen syntaktický cukr; je to zásadní vylepšení jazyka, které podporuje bezpečnost, srozumitelnost a udržovatelnost. Tím, že automatizuje zdlouhavý a chybový proces čištění zdrojů, osvobozuje vývojáře, aby se mohli soustředit na svou hlavní obchodní logiku.

Klíčové poznatky jsou:

Až budete začínat nové projekty nebo refaktorovat stávající kód, zvažte přijetí tohoto mocného nového vzoru. Váš JavaScript bude čistší, vaše aplikace spolehlivější a váš život jako vývojáře o něco snazší. Je to skutečně globální standard pro psaní moderního, profesionálního JavaScriptu.