M

MLOG

Hrvatski

Ovladajte novim JavaScriptovim Eksplicitnim Upravljanjem Resursima s `using` i `await using`. Naučite automatizirati čišćenje, spriječiti curenje resursa i pisati čišći, robusniji kod.

Nova Supermoć JavaScripta: Detaljan Uvid u Eksplicitno Upravljanje Resursima

U dinamičnom svijetu razvoja softvera, učinkovito upravljanje resursima je kamen temeljac izgradnje robusnih, pouzdanih i učinkovitih aplikacija. Desetljećima su se JavaScript programeri oslanjali na ručne obrasce poput try...catch...finally kako bi osigurali pravilno oslobađanje kritičnih resursa—poput rukovatelja datotekama, mrežnih veza ili sesija baze podataka. Iako funkcionalan, ovaj pristup je često rječit, sklon pogreškama i može brzo postati nespretan, obrazac koji se ponekad naziva "piramidom propasti" u složenim scenarijima.

Uđite u promjenu paradigme za jezik: Eksplicitno Upravljanje Resursima (ERM). Finalizirana u standardu ECMAScript 2024 (ES2024), ova moćna značajka, inspirirana sličnim konstrukcijama u jezicima poput C#, Pythona i Jave, uvodi deklarativan i automatiziran način rukovanja čišćenjem resursa. Koristeći nove ključne riječi using i await using, JavaScript sada nudi daleko elegantnije i sigurnije rješenje za bezvremenski programski izazov.

Ovaj sveobuhvatni vodič odvest će vas na putovanje kroz JavaScriptovo Eksplicitno Upravljanje Resursima. Istražit ćemo probleme koje rješava, raščlaniti njegove osnovne koncepte, proći kroz praktične primjere i otkriti napredne obrasce koji će vam omogućiti da pišete čišći, otporniji kod, bez obzira gdje se u svijetu razvijate.

Stara Garda: Izazovi Ručnog Čišćenja Resursa

Prije nego što možemo cijeniti eleganciju novog sustava, moramo najprije razumjeti bolne točke starog. Klasični obrazac za upravljanje resursima u JavaScriptu je blok try...finally.

Logika je jednostavna: stječete resurs u bloku try i oslobađate ga u bloku finally. Blok finally jamči izvršenje, bez obzira na to uspijeva li kod u bloku try, ne uspijeva ili se prijevremeno vraća.

Razmotrimo uobičajeni scenarij na strani poslužitelja: otvaranje datoteke, pisanje nekih podataka u nju, a zatim osiguravanje da je datoteka zatvorena.

Primjer: Jednostavna operacija s datotekom s try...finally


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

async function processFile(filePath, data) {
  let fileHandle;
  try {
    console.log('Otvaranje datoteke...');
    fileHandle = await fs.open(filePath, 'w');
    console.log('Pisanje u datoteku...');
    await fileHandle.write(data);
    console.log('Podaci uspješno zapisani.');
  } catch (error) {
    console.error('Došlo je do pogreške tijekom obrade datoteke:', error);
  } finally {
    if (fileHandle) {
      console.log('Zatvaranje datoteke...');
      await fileHandle.close();
    }
  }
}

Ovaj kod radi, ali otkriva nekoliko slabosti:

Sada, zamislite upravljanje višestrukim resursima, poput veze s bazom podataka i rukovatelja datotekom. Kod brzo postaje ugniježđeni nered:


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

Ovo gniježđenje je teško održavati i skalirati. To je jasan signal da je potrebna bolja apstrakcija. Upravo je to problem koji je Eksplicitno Upravljanje Resursima osmišljeno da riješi.

Promjena paradigme: Načela Eksplicitnog Upravljanja Resursima

Eksplicitno Upravljanje Resursima (ERM) uvodi ugovor između objekta resursa i JavaScript runtimea. Glavna ideja je jednostavna: objekt može deklarirati kako bi trebao biti očišćen, a jezik pruža sintaksu za automatsko izvršavanje tog čišćenja kada objekt izađe iz opsega.

To se postiže kroz dvije glavne komponente:

  1. Protokol za odlaganje: Standardni način za objekte da definiraju vlastitu logiku čišćenja pomoću posebnih simbola: Symbol.dispose za sinkrono čišćenje i Symbol.asyncDispose za asinkrono čišćenje.
  2. Deklaracije `using` i `await using`: Nove ključne riječi koje povezuju resurs s blok-opsegom. Kada se blok napusti, automatski se poziva metoda čišćenja resursa.

Osnovni koncepti: `Symbol.dispose` i `Symbol.asyncDispose`

U srcu ERM-a su dva nova poznata Simbola. Objekt koji ima metodu s jednim od ovih simbola kao ključem smatra se "resursom za jednokratnu upotrebu".

Sinkrono odlaganje s `Symbol.dispose`

Simbol Symbol.dispose specificira sinkronu metodu čišćenja. To je prikladno za resurse gdje čišćenje ne zahtijeva nikakve asinkrone operacije, poput sinkronog zatvaranja rukovatelja datotekom ili oslobađanja brave u memoriji.

Stvorimo omotač za privremenu datoteku koja se sama čisti.


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(`Stvorena privremena datoteka: ${this.path}`);
  }

  // Ovo je sinkrona metoda za odlaganje
  [Symbol.dispose]() {
    console.log(`Odlaganje privremene datoteke: ${this.path}`);
    try {
      fs.unlinkSync(this.path);
      console.log('Datoteka uspješno izbrisana.');
    } catch (error) {
      console.error(`Nije uspjelo brisanje datoteke: ${this.path}`, error);
      // Važno je obraditi i pogreške unutar dispose!
    }
  }
}

Svaka instanca `TempFile` sada je resurs za jednokratnu upotrebu. Ima metodu s ključem Symbol.dispose koja sadrži logiku za brisanje datoteke s diska.

Asinkrono odlaganje s `Symbol.asyncDispose`

Mnoge moderne operacije čišćenja su asinkrone. Zatvaranje veze s bazom podataka može uključivati ​​slanje naredbe `QUIT` preko mreže, ili klijent reda poruka možda će morati isprazniti izlazni međuspremnik. Za ove scenarije koristimo `Symbol.asyncDispose`.

Metoda povezana sa Symbol.asyncDispose mora vratiti `Promise` (ili biti `async` funkcija).

Modelirajmo lažnu vezu s bazom podataka koju je potrebno asinkrono vratiti u skup.


// Lažni skup baze podataka
const mockDbPool = {
  getConnection: () => {
    console.log('DB veza stečena.');
    return new MockDbConnection();
  }
};

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

  // Ovo je asinkrona metoda za odlaganje
  async [Symbol.asyncDispose]() {
    console.log('Vraćanje DB veze u skup...');
    // Simulirajte mrežno kašnjenje za oslobađanje veze
    await new Promise(resolve => setTimeout(resolve, 50));
    console.log('DB veza oslobođena.');
  }
}

Sada je svaka instanca `MockDbConnection` asinkroni resurs za odlaganje. Zna kako se asinkrono osloboditi kada više nije potreban.

Nova sintaksa: `using` i `await using` u akciji

S definiranim klasama za jednokratnu upotrebu, sada ih možemo koristiti s novim ključnim riječima za automatsko upravljanje njima. Ove ključne riječi stvaraju deklaracije opsega bloka, baš kao i `let` i `const`.

Sinkrono čišćenje s `using`

Ključna riječ `using` koristi se za resurse koji implementiraju `Symbol.dispose`. Kada izvršavanje koda napusti blok u kojem je napravljena deklaracija `using`, metoda `[Symbol.dispose]()` se automatski poziva.

Upotrijebimo našu klasu `TempFile`:


function processDataWithTempFile() {
  console.log('Ulazak u blok...');
  using tempFile = new TempFile('Ovo su neki važni podaci.');

  // Ovdje možete raditi s tempFileom
  const content = fs.readFileSync(tempFile.path, 'utf8');
  console.log(`Pročitano iz privremene datoteke: "${content}"`);

  // Nije potreban kod za čišćenje ovdje!
  console.log('...radim više posla...');
} // <-- tempFile.[Symbol.dispose]() se automatski poziva upravo ovdje!

processDataWithTempFile();
console.log('Blok je napušten.');

Izlaz bi bio:

Ulazak u blok...
Stvorena privremena datoteka: /put/do/temp_1678886400000.txt
Pročitano iz privremene datoteke: "Ovo su neki važni podaci."
...radim više posla...
Odlaganje privremene datoteke: /put/do/temp_1678886400000.txt
Datoteka uspješno izbrisana.
Blok je napušten.

Pogledajte kako je čisto! Cijeli životni ciklus resursa sadržan je unutar bloka. Mi ga deklariramo, koristimo ga i zaboravljamo na njega. Jezik se brine za čišćenje. Ovo je ogromno poboljšanje u čitljivosti i sigurnosti.

Upravljanje višestrukim resursima

Možete imati više deklaracija `using` u istom bloku. Oni će se odlagati obrnutim redoslijedom njihovog stvaranja (ponašanje slično LIFO ili "stack").


{
  using resourceA = new MyDisposable('A'); // Stvoreno prvo
  using resourceB = new MyDisposable('B'); // Stvoreno drugo
  console.log('Unutar bloka, korištenje resursa...');
} // resourceB se odlaže prvi, zatim resourceA

Asinkrono čišćenje s `await using`

Ključna riječ `await using` je asinkroni pandan `using`. Koristi se za resurse koji implementiraju `Symbol.asyncDispose`. Budući da je čišćenje asinkrono, ova se ključna riječ može koristiti samo unutar `async` funkcije ili na najvišoj razini modula (ako je podržano await na najvišoj razini).

Upotrijebimo našu klasu `MockDbConnection`:


async function performDatabaseOperation() {
  console.log('Ulazak u asinkronu funkciju...');
  await using db = mockDbPool.getConnection();

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

  console.log('Operacija s bazom podataka dovršena.');
} // <-- await db.[Symbol.asyncDispose]() se automatski poziva ovdje!

(async () => {
  await performDatabaseOperation();
  console.log('Asinkrona funkcija je dovršena.');
})();

Izlaz demonstrira asinkrono čišćenje:

Ulazak u asinkronu funkciju...
DB veza stečena.
Izvršavanje upita: SELECT * FROM users
Operacija s bazom podataka dovršena.
Vraćanje DB veze u skup...
(čeka 50ms)
DB veza oslobođena.
Asinkrona funkcija je dovršena.

Baš kao i kod `using`, sintaksa `await using` rukuje cijelim životnim ciklusom, ali ispravno `čeka` asinkroni proces čišćenja. Može čak i rukovati resursima koji su samo sinkrono za jednokratnu upotrebu—jednostavno ih neće čekati.

Napredni obrasci: `DisposableStack` i `AsyncDisposableStack`

Ponekad jednostavan opseg bloka `using` nije dovoljno fleksibilan. Što ako trebate upravljati skupinom resursa s trajanjem koje nije vezano za jedan leksički blok? Ili što ako se integrirate sa starijom bibliotekom koja ne proizvodi objekte s `Symbol.dispose`?

Za ove scenarije, JavaScript pruža dvije pomoćne klase: `DisposableStack` i `AsyncDisposableStack`.

`DisposableStack`: Upravitelj fleksibilnim čišćenjem

A `DisposableStack` je objekt koji upravlja kolekcijom operacija čišćenja. I sam je resurs za jednokratnu upotrebu, tako da možete upravljati cijelim njegovim životnim vijekom s blokom `using`.

Ima nekoliko korisnih metoda:

Primjer: Uvjetno upravljanje resursima

Zamislite funkciju koja otvara datoteku zapisnika samo ako je ispunjen određeni uvjet, ali želite da se sve čišćenje dogodi na jednom mjestu na kraju.


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

  const db = stack.use(getDbConnection()); // Uvijek koristite DB

  if (shouldLog) {
    const logFileStream = fs.createWriteStream('app.log');
    // Odgodi čišćenje za tok
    stack.defer(() => {
      console.log('Zatvaranje toka datoteke zapisnika...');
      logFileStream.end();
    });
    db.logTo(logFileStream);
  }

  db.doWork();

} // <-- Stog se odlaže, pozivajući sve registrirane funkcije čišćenja redoslijedom LIFO.

`AsyncDisposableStack`: Za asinkroni svijet

Kao što pretpostavljate, `AsyncDisposableStack` je asinkrona verzija. Može upravljati i sinkronim i asinkronim resursima za jednokratnu upotrebu. Njegova primarna metoda čišćenja je `.disposeAsync()`, koja vraća `Promise` koji se rješava kada su sve asinkrone operacije čišćenja dovršene.

Primjer: Upravljanje mješavinom resursa

Stvorimo rukovatelj zahtjevima web poslužitelja kojem je potrebna veza s bazom podataka (asinkrono čišćenje) i privremena datoteka (sinkrono čišćenje).


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

  // Upravljajte asinkronim resursom za jednokratnu upotrebu
  const dbConnection = await stack.use(getAsyncDbConnection());

  // Upravljajte sinkronim resursom za jednokratnu upotrebu
  const tempFile = stack.use(new TempFile('podaci zahtjeva'));

  // Usvoji resurs iz stare API-ja
  const legacyResource = getLegacyResource();
  stack.adopt(legacyResource, () => legacyResource.shutdown());

  console.log('Obrada zahtjeva...');
  await doWork(dbConnection, tempFile.path);

} // <-- stack.disposeAsync() se poziva. Ispravno će čekati asinkrono čišćenje.

`AsyncDisposableStack` je moćan alat za orkestriranje složene logike postavljanja i rastavljanja na čist, predvidljiv način.

Robusna obrada pogrešaka s `SuppressedError`

Jedno od najsuptilnijih, ali značajnih poboljšanja ERM-a je način na koji rukuje pogreškama. Što se događa ako se pogreška baca unutar bloka `using`, i *druga* pogreška se baca tijekom naknadnog automatskog odlaganja?

U starom svijetu `try...finally`, pogreška iz bloka `finally` bi obično prebrisala ili "potisnula" izvornu, važniju pogrešku iz bloka `try`. To je često otežavalo otklanjanje pogrešaka nevjerojatno.

ERM to rješava s novom globalnom vrstom pogreške: `SuppressedError`. Ako se pogreška dogodi tijekom odlaganja dok se druga pogreška već širi, pogreška odlaganja je "potisnuta". Izvorna pogreška je bačena, ali sada ima svojstvo `suppressed` koje sadrži pogrešku odlaganja.


class FaultyResource {
  [Symbol.dispose]() {
    throw new Error('Pogreška tijekom odlaganja!');
  }
}

try {
  using resource = new FaultyResource();
  throw new Error('Pogreška tijekom operacije!');
} catch (e) {
  console.log(`Uhvaćena pogreška: ${e.message}`); // Pogreška tijekom operacije!
  if (e.suppressed) {
    console.log(`Potisnuta pogreška: ${e.suppressed.message}`); // Pogreška tijekom odlaganja!
    console.log(e instanceof SuppressedError); // false
    console.log(e.suppressed instanceof Error); // true
  }
}

Ovo ponašanje osigurava da nikada ne izgubite kontekst izvornog kvara, što dovodi do mnogo robusnijih i ispravljivijih sustava.

Praktični slučajevi upotrebe u cijelom JavaScript ekosustavu

Primjene Eksplicitnog Upravljanja Resursima su ogromne i relevantne za programere diljem svijeta, bez obzira na to rade li na pozadini, prednjem dijelu ili u testiranju.

Podrška za preglednik i runtime

Kao moderna značajka, važno je znati gdje možete koristiti Eksplicitno Upravljanje Resursima. Od kasne 2023. / početka 2024., podrška je raširena u najnovijim verzijama glavnih JavaScript okruženja:

Za starija okruženja, morat ćete se osloniti na transpajlere poput Babela s odgovarajućim dodacima za transformaciju sintakse `using` i popunjavanje potrebnih simbola i klasa stogova.

Zaključak: Nova era sigurnosti i jasnoće

JavaScriptovo Eksplicitno Upravljanje Resursima je više od sintaktičkog šećera; to je temeljno poboljšanje jezika koje promiče sigurnost, jasnoću i održivost. Automatiziranjem dosadnog i sklonog pogreškama procesa čišćenja resursa, oslobađa programere da se usredotoče na svoju primarnu poslovnu logiku.

Ključni zaključci su:

Dok započinjete nove projekte ili refaktorirate postojeći kod, razmislite o usvajanju ovog moćnog novog obrasca. Učinit će vaš JavaScript čišćim, vaše aplikacije pouzdanijima i vaš život kao programera samo malo lakšim. To je istinski globalni standard za pisanje modernog, profesionalnog JavaScripta.