M

MLOG

తెలుగు

`using` మరియు `await using`తో జావాస్క్రిప్ట్ యొక్క కొత్త ఎక్స్‌ప్లిసిట్ రిసోర్స్ మేనేజ్‌మెంట్‌లో నైపుణ్యం సాధించండి. క్లీనప్‌ను ఆటోమేట్ చేయడం, రిసోర్స్ లీక్‌లను నివారించడం, మరియు మరింత శుభ్రమైన, బలమైన కోడ్ రాయడం నేర్చుకోండి.

జావాస్క్రిప్ట్ యొక్క కొత్త సూపర్ పవర్: ఎక్స్‌ప్లిసిట్ రిసోర్స్ మేనేజ్‌మెంట్‌పై ఒక లోతైన విశ్లేషణ

సాఫ్ట్‌వేర్ డెవలప్‌మెంట్ యొక్క డైనమిక్ ప్రపంచంలో, దృఢమైన, విశ్వసనీయమైన, మరియు సమర్థవంతమైన అప్లికేషన్‌లను రూపొందించడంలో వనరులను సమర్థవంతంగా నిర్వహించడం ఒక మూలస్తంభం. దశాబ్దాలుగా, జావాస్క్రిప్ట్ డెవలపర్లు ఫైల్ హ్యాండిల్స్, నెట్‌వర్క్ కనెక్షన్‌లు, లేదా డేటాబేస్ సెషన్‌లు వంటి క్లిష్టమైన వనరులను సరిగ్గా విడుదల చేయడానికి try...catch...finally వంటి మాన్యువల్ పద్ధతులపై ఆధారపడ్డారు. ఇది పని చేసినప్పటికీ, ఈ విధానం తరచుగా పెద్దదిగా, దోషపూరితంగా ఉంటుంది, మరియు సంక్లిష్ట సందర్భాలలో త్వరగా గజిబిజిగా మారుతుంది, దీనిని కొన్నిసార్లు 'పిరమిడ్ ఆఫ్ డూమ్' అని కూడా అంటారు.

ఇప్పుడు భాష కోసం ఒక కొత్త నమూనా మార్పు వచ్చింది: ఎక్స్‌ప్లిసిట్ రిసోర్స్ మేనేజ్‌మెంట్ (ERM). ECMAScript 2024 (ES2024) ప్రమాణంలో ఖరారు చేయబడిన ఈ శక్తివంతమైన ఫీచర్, C#, పైథాన్, మరియు జావా వంటి భాషలలోని ఇలాంటి నిర్మాణాల నుండి ప్రేరణ పొంది, రిసోర్స్ క్లీనప్‌ను నిర్వహించడానికి ఒక డిక్లరేటివ్ మరియు ఆటోమేటెడ్ మార్గాన్ని పరిచయం చేస్తుంది. కొత్త using మరియు await using కీవర్డ్‌లను ఉపయోగించడం ద్వారా, జావాస్క్రిప్ట్ ఇప్పుడు ఒక శాశ్వతమైన ప్రోగ్రామింగ్ సవాలుకు మరింత సొగసైన మరియు సురక్షితమైన పరిష్కారాన్ని అందిస్తుంది.

ఈ సమగ్ర మార్గదర్శి మిమ్మల్ని జావాస్క్రిప్ట్ యొక్క ఎక్స్‌ప్లిసిట్ రిసోర్స్ మేనేజ్‌మెంట్ ద్వారా ఒక ప్రయాణంలో తీసుకెళ్తుంది. ఇది పరిష్కరించే సమస్యలను అన్వేషిస్తాం, దాని ముఖ్య భావనలను విశ్లేషిస్తాం, ఆచరణాత్మక ఉదాహరణల ద్వారా నడుస్తాం, మరియు మీరు ప్రపంచంలో ఎక్కడ అభివృద్ధి చేస్తున్నా, మరింత శుభ్రమైన, మరింత స్థిరమైన కోడ్‌ను వ్రాయడానికి మీకు అధికారం ఇచ్చే అధునాతన పద్ధతులను వెలికితీస్తాం.

పాత పద్ధతి: మాన్యువల్ రిసోర్స్ క్లీనప్ యొక్క సవాళ్లు

కొత్త వ్యవస్థ యొక్క సొగసును మనం అభినందించడానికి ముందు, మనం పాత దానిలోని ఇబ్బందులను అర్థం చేసుకోవాలి. జావాస్క్రిప్ట్‌లో రిసోర్స్ మేనేజ్‌మెంట్ కోసం క్లాసిక్ పద్ధతి try...finally బ్లాక్.

దాని తర్కం సులభం: మీరు try బ్లాక్‌లో ఒక వనరును పొందుతారు, మరియు మీరు దానిని finally బ్లాక్‌లో విడుదల చేస్తారు. finally బ్లాక్, try బ్లాక్‌లోని కోడ్ విజయవంతమైనా, విఫలమైనా, లేదా ముందుగానే తిరిగి వచ్చినా అమలును హామీ ఇస్తుంది.

ఒక సాధారణ సర్వర్-సైడ్ దృష్టాంతాన్ని పరిశీలిద్దాం: ఒక ఫైల్‌ను తెరవడం, దానికి కొంత డేటాను వ్రాయడం, ఆపై ఫైల్ మూసివేయబడిందని నిర్ధారించుకోవడం.

ఉదాహరణ: try...finallyతో ఒక సాధారణ ఫైల్ ఆపరేషన్


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

async function processFile(filePath, data) {
  let fileHandle;
  try {
    console.log('Opening file...');
    fileHandle = await fs.open(filePath, 'w');
    console.log('Writing to file...');
    await fileHandle.write(data);
    console.log('Data written successfully.');
  } catch (error) {
    console.error('An error occurred during file processing:', error);
  } finally {
    if (fileHandle) {
      console.log('Closing file...');
      await fileHandle.close();
    }
  }
}

ఈ కోడ్ పని చేస్తుంది, కానీ ఇది అనేక బలహీనతలను వెల్లడిస్తుంది:

ఇప్పుడు, డేటాబేస్ కనెక్షన్ మరియు ఫైల్ హ్యాండిల్ వంటి బహుళ వనరులను నిర్వహించడం ఊహించుకోండి. కోడ్ త్వరగా ఒక గూడుకట్టిన గందరగోళంగా మారుతుంది:


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

ఈ నెస్టింగ్ నిర్వహించడం మరియు స్కేల్ చేయడం కష్టం. ఇది ఒక మంచి అబ్స్ట్రాక్షన్ అవసరమని స్పష్టమైన సంకేతం. ఎక్స్‌ప్లిసిట్ రిసోర్స్ మేనేజ్‌మెంట్ ఖచ్చితంగా ఈ సమస్యను పరిష్కరించడానికి రూపొందించబడింది.

ఒక నమూనా మార్పు: ఎక్స్‌ప్లిసిట్ రిసోర్స్ మేనేజ్‌మెంట్ యొక్క సూత్రాలు

ఎక్స్‌ప్లిసిట్ రిసోర్స్ మేనేజ్‌మెంట్ (ERM) ఒక వనరు ఆబ్జెక్ట్ మరియు జావాస్క్రిప్ట్ రన్‌టైమ్ మధ్య ఒక ఒప్పందాన్ని పరిచయం చేస్తుంది. ప్రధాన ఆలోచన సులభం: ఒక ఆబ్జెక్ట్ దానిని ఎలా శుభ్రపరచాలో ప్రకటించగలదు, మరియు ఆబ్జెక్ట్ స్కోప్ నుండి బయటకు వెళ్ళినప్పుడు ఆ క్లీనప్‌ను ఆటోమేటిక్‌గా నిర్వహించడానికి భాష సింటాక్స్‌ను అందిస్తుంది.

ఇది రెండు ప్రధాన భాగాల ద్వారా సాధించబడుతుంది:

  1. డిస్పోజబుల్ ప్రోటోకాల్: ఆబ్జెక్ట్‌లు తమ స్వంత క్లీనప్ లాజిక్‌ను ప్రత్యేక చిహ్నాలను ఉపయోగించి నిర్వచించడానికి ఒక ప్రామాణిక మార్గం: సింక్రోనస్ క్లీనప్ కోసం Symbol.dispose మరియు అసింక్రోనస్ క్లీనప్ కోసం Symbol.asyncDispose.
  2. `using` మరియు `await using` డిక్లరేషన్‌లు: ఒక వనరును బ్లాక్ స్కోప్‌కు బంధించే కొత్త కీవర్డ్‌లు. బ్లాక్ నుండి నిష్క్రమించినప్పుడు, వనరు యొక్క క్లీనప్ పద్ధతి ఆటోమేటిక్‌గా పిలువబడుతుంది.

ప్రధాన భావనలు: `Symbol.dispose` మరియు `Symbol.asyncDispose`

ERM యొక్క గుండెలో రెండు కొత్త సుప్రసిద్ధ సింబల్స్ ఉన్నాయి. ఈ సింబల్స్‌లో ఒకదానిని కీగా ఉన్న ఒక పద్ధతిని కలిగి ఉన్న ఆబ్జెక్ట్‌ను "డిస్పోజబుల్ రిసోర్స్"గా పరిగణిస్తారు.

`Symbol.dispose`తో సింక్రోనస్ డిస్పోజల్

Symbol.dispose సింబల్ ఒక సింక్రోనస్ క్లీనప్ పద్ధతిని నిర్దేశిస్తుంది. ఫైల్ హ్యాండిల్‌ను సింక్రోనస్‌గా మూసివేయడం లేదా ఇన్-మెమరీ లాక్‌ను విడుదల చేయడం వంటి ఏ అసింక్రోనస్ ఆపరేషన్‌లు అవసరం లేని వనరులకు ఇది అనుకూలంగా ఉంటుంది.

ఒక తాత్కాలిక ఫైల్ కోసం ఒక వ్రాపర్‌ను సృష్టిద్దాం, అది తనను తాను శుభ్రపరుచుకుంటుంది.


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(`Created temp file: ${this.path}`);
  }

  // ఇది సింక్రోనస్ డిస్పోజబుల్ పద్ధతి
  [Symbol.dispose]() {
    console.log(`Disposing temp file: ${this.path}`);
    try {
      fs.unlinkSync(this.path);
      console.log('File deleted successfully.');
    } catch (error) {
      console.error(`Failed to delete file: ${this.path}`, error);
      // డిస్పోజ్‌లో కూడా దోషాలను హ్యాండిల్ చేయడం ముఖ్యం!
    }
  }
}

`TempFile` యొక్క ఏ ఇన్‌స్టాన్స్ అయినా ఇప్పుడు ఒక డిస్పోజబుల్ రిసోర్స్. ఇది `Symbol.dispose` ద్వారా కీ చేయబడిన ఒక పద్ధతిని కలిగి ఉంది, ఇది ఫైల్‌ను డిస్క్ నుండి తొలగించే లాజిక్‌ను కలిగి ఉంటుంది.

`Symbol.asyncDispose`తో అసింక్రోనస్ డిస్పోజల్

అనేక ఆధునిక క్లీనప్ ఆపరేషన్‌లు అసింక్రోనస్‌గా ఉంటాయి. డేటాబేస్ కనెక్షన్‌ను మూసివేయడానికి నెట్‌వర్క్ ద్వారా `QUIT` కమాండ్‌ను పంపడం అవసరం కావచ్చు, లేదా ఒక మెసేజ్ క్యూ క్లయింట్ దాని అవుట్‌గోయింగ్ బఫర్‌ను ఫ్లష్ చేయాల్సి రావచ్చు. ఈ సందర్భాల కోసం, మనం `Symbol.asyncDispose`ను ఉపయోగిస్తాం.

`Symbol.asyncDispose`తో అనుబంధించబడిన పద్ధతి ఒక `Promise`ను తిరిగి ఇవ్వాలి (లేదా ఒక `async` ఫంక్షన్‌గా ఉండాలి).

ఒక మాక్ డేటాబేస్ కనెక్షన్‌ను మోడల్ చేద్దాం, దానిని అసింక్రోనస్‌గా ఒక పూల్‌కు తిరిగి విడుదల చేయాలి.


// ఒక మాక్ డేటాబేస్ పూల్
const mockDbPool = {
  getConnection: () => {
    console.log('DB connection acquired.');
    return new MockDbConnection();
  }
};

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

  // ఇది అసింక్రోనస్ డిస్పోజబుల్ పద్ధతి
  async [Symbol.asyncDispose]() {
    console.log('Releasing DB connection back to the pool...');
    // కనెక్షన్‌ను విడుదల చేయడానికి ఒక నెట్‌వర్క్ ఆలస్యాన్ని అనుకరించండి
    await new Promise(resolve => setTimeout(resolve, 50));
    console.log('DB connection released.');
  }
}

ఇప్పుడు, ఏ `MockDbConnection` ఇన్‌స్టాన్స్ అయినా ఒక అసింక్ డిస్పోజబుల్ రిసోర్స్. అది ఇకపై అవసరం లేనప్పుడు తనను తాను అసింక్రోనస్‌గా ఎలా విడుదల చేసుకోవాలో దానికి తెలుసు.

కొత్త సింటాక్స్: `using` మరియు `await using` ఆచరణలో

మన డిస్పోజబుల్ క్లాస్‌లను నిర్వచించిన తర్వాత, వాటిని ఆటోమేటిక్‌గా నిర్వహించడానికి మనం ఇప్పుడు కొత్త కీవర్డ్‌లను ఉపయోగించవచ్చు. ఈ కీవర్డ్‌లు `let` మరియు `const` లాగా బ్లాక్-స్కోప్డ్ డిక్లరేషన్‌లను సృష్టిస్తాయి.

`using`తో సింక్రోనస్ క్లీనప్

`using` కీవర్డ్ `Symbol.dispose`ను అమలు చేసే వనరుల కోసం ఉపయోగించబడుతుంది. `using` డిక్లరేషన్ చేయబడిన బ్లాక్ నుండి కోడ్ ఎగ్జిక్యూషన్ నిష్క్రమించినప్పుడు, `[Symbol.dispose]()` పద్ధతి ఆటోమేటిక్‌గా పిలువబడుతుంది.

మన `TempFile` క్లాస్‌ను ఉపయోగిద్దాం:


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

  // మీరు ఇక్కడ tempFile తో పని చేయవచ్చు
  const content = fs.readFileSync(tempFile.path, 'utf8');
  console.log(`Read from temp file: "${content}"`);

  // ఇక్కడ క్లీనప్ కోడ్ అవసరం లేదు!
  console.log('...doing more work...');
} // <-- tempFile.[Symbol.dispose]() ఇక్కడే ఆటోమేటిక్‌గా పిలువబడుతుంది!

processDataWithTempFile();
console.log('Block has been exited.');

అవుట్‌పుట్ ఇలా ఉంటుంది:

Entering block...
Created temp file: /path/to/temp_1678886400000.txt
Read from temp file: "This is some important data."
...doing more work...
Disposing temp file: /path/to/temp_1678886400000.txt
File deleted successfully.
Block has been exited.

అది ఎంత శుభ్రంగా ఉందో చూడండి! వనరు యొక్క పూర్తి జీవితచక్రం బ్లాక్‌లో ఉంటుంది. మనం దానిని ప్రకటిస్తాం, ఉపయోగిస్తాం, మరియు దాని గురించి మరచిపోతాం. భాష క్లీనప్‌ను నిర్వహిస్తుంది. ఇది చదవడానికి మరియు భద్రతలో ఒక భారీ మెరుగుదల.

బహుళ వనరులను నిర్వహించడం

మీరు ఒకే బ్లాక్‌లో బహుళ `using` డిక్లరేషన్‌లను కలిగి ఉండవచ్చు. అవి సృష్టించబడిన రివర్స్ ఆర్డర్‌లో (LIFO లేదా "స్టాక్-వంటి" ప్రవర్తన) డిస్పోజ్ చేయబడతాయి.


{
  using resourceA = new MyDisposable('A'); // మొదట సృష్టించబడింది
  using resourceB = new MyDisposable('B'); // రెండవది సృష్టించబడింది
  console.log('Inside block, using resources...');
} // resourceB మొదట డిస్పోజ్ చేయబడుతుంది, ఆపై resourceA

`await using`తో అసింక్రోనస్ క్లీనప్

`await using` కీవర్డ్ `using`కు అసింక్రోనస్ ప్రతిరూపం. ఇది `Symbol.asyncDispose`ను అమలు చేసే వనరుల కోసం ఉపయోగించబడుతుంది. క్లీనప్ అసింక్రోనస్ కాబట్టి, ఈ కీవర్డ్‌ను కేవలం `async` ఫంక్షన్ లోపల లేదా మాడ్యూల్ యొక్క ఉన్నత స్థాయిలో (టాప్-లెవల్ await మద్దతు ఉంటే) మాత్రమే ఉపయోగించవచ్చు.

మన `MockDbConnection` క్లాస్‌ను ఉపయోగిద్దాం:


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

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

  console.log('Database operation complete.');
} // <-- await db.[Symbol.asyncDispose]() ఇక్కడే ఆటోమేటిక్‌గా పిలువబడుతుంది!

(async () => {
  await performDatabaseOperation();
  console.log('Async function has completed.');
})();

అవుట్‌పుట్ అసింక్రోనస్ క్లీనప్‌ను ప్రదర్శిస్తుంది:

Entering async function...
DB connection acquired.
Executing query: SELECT * FROM users
Database operation complete.
Releasing DB connection back to the pool...
(waits 50ms)
DB connection released.
Async function has completed.

`using`తో లాగే, `await using` సింటాక్స్ పూర్తి జీవితచక్రాన్ని నిర్వహిస్తుంది, కానీ అది అసింక్రోనస్ క్లీనప్ ప్రక్రియను సరిగ్గా `await` చేస్తుంది. ఇది కేవలం సింక్రోనస్‌గా డిస్పోజబుల్ అయ్యే వనరులను కూడా హ్యాండిల్ చేయగలదు—అది వాటిని `await` చేయదు.

అధునాతన పద్ధతులు: `DisposableStack` మరియు `AsyncDisposableStack`

కొన్నిసార్లు, `using` యొక్క సాధారణ బ్లాక్-స్కోపింగ్ తగినంత ఫ్లెక్సిబుల్‌గా ఉండదు. ఒకే లెక్సికల్ బ్లాక్‌కు కట్టుబడి లేని జీవితకాలంతో మీరు వనరుల సమూహాన్ని నిర్వహించాల్సి వస్తే? లేదా మీరు `Symbol.dispose`తో ఆబ్జెక్ట్‌లను ఉత్పత్తి చేయని పాత లైబ్రరీతో ఇంటిగ్రేట్ చేస్తుంటే?

ఈ సందర్భాల కోసం, జావాస్క్రిప్ట్ రెండు సహాయక క్లాస్‌లను అందిస్తుంది: `DisposableStack` మరియు `AsyncDisposableStack`.

`DisposableStack`: ఫ్లెక్సిబుల్ క్లీనప్ మేనేజర్

ఒక `DisposableStack` అనేది క్లీనప్ ఆపరేషన్‌ల సేకరణను నిర్వహించే ఒక ఆబ్జెక్ట్. ఇది కూడా ఒక డిస్పోజబుల్ రిసోర్స్, కాబట్టి మీరు దాని పూర్తి జీవితకాలాన్ని ఒక `using` బ్లాక్‌తో నిర్వహించవచ్చు.

దీనికి అనేక ఉపయోగకరమైన పద్ధతులు ఉన్నాయి:

ఉదాహరణ: షరతులతో కూడిన వనరుల నిర్వహణ

ఒక నిర్దిష్ట షరతు నెరవేరినప్పుడు మాత్రమే ఒక లాగ్ ఫైల్‌ను తెరిచే ఫంక్షన్‌ను ఊహించుకోండి, కానీ మీరు అన్ని క్లీనప్‌లు చివరలో ఒకే చోట జరగాలని కోరుకుంటారు.


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

  const db = stack.use(getDbConnection()); // ఎల్లప్పుడూ DBని ఉపయోగించండి

  if (shouldLog) {
    const logFileStream = fs.createWriteStream('app.log');
    // స్ట్రీమ్ కోసం క్లీనప్‌ను వాయిదా వేయండి
    stack.defer(() => {
      console.log('Closing log file stream...');
      logFileStream.end();
    });
    db.logTo(logFileStream);
  }

  db.doWork();

} // <-- స్టాక్ డిస్పోజ్ చేయబడుతుంది, LIFO ఆర్డర్‌లో అన్ని రిజిస్టర్డ్ క్లీనప్ ఫంక్షన్‌లను పిలుస్తుంది.

`AsyncDisposableStack`: అసింక్రోనస్ ప్రపంచం కోసం

మీరు ఊహించినట్లుగా, `AsyncDisposableStack` అసింక్రోనస్ వెర్షన్. ఇది సింక్రోనస్ మరియు అసింక్రోనస్ డిస్పోజబుల్స్‌ను రెండింటినీ నిర్వహించగలదు. దీని ప్రధాన క్లీనప్ పద్ధతి `.disposeAsync()`, ఇది అన్ని అసింక్రోనస్ క్లీనప్ ఆపరేషన్‌లు పూర్తయినప్పుడు రిజాల్వ్ అయ్యే ఒక `Promise`ను తిరిగి ఇస్తుంది.

ఉదాహరణ: వనరుల మిశ్రమాన్ని నిర్వహించడం

ఒక వెబ్ సర్వర్ రిక్వెస్ట్ హ్యాండ్లర్‌ను సృష్టిద్దాం, దీనికి డేటాబేస్ కనెక్షన్ (అసింక్ క్లీనప్) మరియు తాత్కాలిక ఫైల్ (సింక్ క్లీనప్) అవసరం.


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

  // ఒక అసింక్ డిస్పోజబుల్ రిసోర్స్‌ను నిర్వహించండి
  const dbConnection = await stack.use(getAsyncDbConnection());

  // ఒక సింక్ డిస్పోజబుల్ రిసోర్స్‌ను నిర్వహించండి
  const tempFile = stack.use(new TempFile('request data'));

  // పాత API నుండి ఒక వనరును స్వీకరించండి
  const legacyResource = getLegacyResource();
  stack.adopt(legacyResource, () => legacyResource.shutdown());

  console.log('Processing request...');
  await doWork(dbConnection, tempFile.path);

} // <-- stack.disposeAsync() పిలువబడుతుంది. ఇది అసింక్ క్లీనప్‌ను సరిగ్గా await చేస్తుంది.

`AsyncDisposableStack` సంక్లిష్టమైన సెటప్ మరియు టీర్‌డౌన్ లాజిక్‌ను ఒక శుభ్రమైన, ఊహించదగిన పద్ధతిలో ఆర్కెస్ట్రేట్ చేయడానికి ఒక శక్తివంతమైన సాధనం.

`SuppressedError`తో దృఢమైన ఎర్రర్ హ్యాండ్లింగ్

ERM యొక్క అత్యంత సూక్ష్మమైన కానీ ముఖ్యమైన మెరుగుదలలలో ఒకటి అది దోషాలను ఎలా నిర్వహిస్తుందో. `using` బ్లాక్ లోపల ఒక దోషం త్రో చేయబడి, ఆ తర్వాత ఆటోమేటిక్ డిస్పోజల్ సమయంలో *మరొక* దోషం త్రో చేయబడితే ఏమి జరుగుతుంది?

పాత `try...finally` ప్రపంచంలో, `finally` బ్లాక్ నుండి వచ్చిన దోషం సాధారణంగా `try` బ్లాక్ నుండి వచ్చిన అసలు, మరింత ముఖ్యమైన దోషాన్ని భర్తీ చేస్తుంది లేదా 'అణచివేస్తుంది'. ఇది తరచుగా డీబగ్గింగ్‌ను చాలా కష్టతరం చేస్తుంది.

ERM దీనిని ఒక కొత్త గ్లోబల్ ఎర్రర్ రకంతో పరిష్కరిస్తుంది: `SuppressedError`. ఒక దోషం ఇప్పటికే ప్రచారం అవుతున్నప్పుడు డిస్పోజల్ సమయంలో ఒక దోషం సంభవిస్తే, డిస్పోజల్ దోషం "అణచివేయబడుతుంది." అసలు దోషం త్రో చేయబడుతుంది, కానీ దానికి ఇప్పుడు డిస్పోజల్ దోషాన్ని కలిగి ఉన్న ఒక `suppressed` ప్రాపర్టీ ఉంటుంది.


class FaultyResource {
  [Symbol.dispose]() {
    throw new Error('Error during disposal!');
  }
}

try {
  using resource = new FaultyResource();
  throw new Error('Error during operation!');
} catch (e) {
  console.log(`Caught error: ${e.message}`); // Error during operation!
  if (e.suppressed) {
    console.log(`Suppressed error: ${e.suppressed.message}`); // Error during disposal!
    console.log(e instanceof SuppressedError); // false
    console.log(e.suppressed instanceof Error); // true
  }
}

ఈ ప్రవర్తన మీరు అసలు వైఫల్యం యొక్క సందర్భాన్ని ఎప్పటికీ కోల్పోకుండా నిర్ధారిస్తుంది, ఇది మరింత దృఢమైన మరియు డీబగ్ చేయగల సిస్టమ్‌లకు దారితీస్తుంది.

జావాస్క్రిప్ట్ ఎకోసిస్టమ్‌లో ఆచరణాత్మక వినియోగ సందర్భాలు

ఎక్స్‌ప్లిసిట్ రిసోర్స్ మేనేజ్‌మెంట్ యొక్క అప్లికేషన్‌లు చాలా విస్తృతమైనవి మరియు ప్రపంచవ్యాప్తంగా డెవలపర్‌లకు సంబంధించినవి, వారు బ్యాక్-ఎండ్, ఫ్రంట్-ఎండ్, లేదా టెస్టింగ్‌లో పనిచేస్తున్నా.

బ్రౌజర్ మరియు రన్‌టైమ్ మద్దతు

ఒక ఆధునిక ఫీచర్‌గా, మీరు ఎక్స్‌ప్లిసిట్ రిసోర్స్ మేనేజ్‌మెంట్‌ను ఎక్కడ ఉపయోగించవచ్చో తెలుసుకోవడం ముఖ్యం. 2023 చివరి / 2024 ప్రారంభం నాటికి, ప్రధాన జావాస్క్రిప్ట్ ఎన్విరాన్‌మెంట్‌ల తాజా వెర్షన్‌లలో మద్దతు విస్తృతంగా ఉంది:

పాత ఎన్విరాన్‌మెంట్‌ల కోసం, మీరు `using` సింటాక్స్‌ను ట్రాన్స్‌ఫార్మ్ చేయడానికి మరియు అవసరమైన సింబల్స్ మరియు స్టాక్ క్లాస్‌లను పాలిఫిల్ చేయడానికి బాబెల్ వంటి ట్రాన్స్‌పైలర్‌లపై ఆధారపడవలసి ఉంటుంది.

ముగింపు: భద్రత మరియు స్పష్టత యొక్క ఒక కొత్త శకం

జావాస్క్రిప్ట్ యొక్క ఎక్స్‌ప్లిసిట్ రిసోర్స్ మేనేజ్‌మెంట్ కేవలం సింటాక్టిక్ షుగర్ కంటే ఎక్కువ; ఇది భద్రత, స్పష్టత, మరియు నిర్వహణను ప్రోత్సహించే భాషకు ఒక ప్రాథమిక మెరుగుదల. రిసోర్స్ క్లీనప్ యొక్క శ్రమతో కూడిన మరియు దోషపూరిత ప్రక్రియను ఆటోమేట్ చేయడం ద్వారా, ఇది డెవలపర్‌లను వారి ప్రాథమిక వ్యాపార లాజిక్‌పై దృష్టి పెట్టడానికి విముక్తి చేస్తుంది.

ముఖ్యమైన అంశాలు:

మీరు కొత్త ప్రాజెక్ట్‌లను ప్రారంభించినప్పుడు లేదా ఇప్పటికే ఉన్న కోడ్‌ను రీఫ్యాక్టర్ చేసినప్పుడు, ఈ శక్తివంతమైన కొత్త పద్ధతిని స్వీకరించడాన్ని పరిగణించండి. ఇది మీ జావాస్క్రిప్ట్‌ను శుభ్రంగా, మీ అప్లికేషన్‌లను మరింత విశ్వసనీయంగా, మరియు ఒక డెవలపర్‌గా మీ జీవితాన్ని కొంచెం సులభతరం చేస్తుంది. ఆధునిక, ప్రొఫెషనల్ జావాస్క్రిప్ట్ రాయడానికి ఇది నిజంగా ఒక గ్లోబల్ స్టాండర్డ్.