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(`અસ્થાયી ફાઇલ બનાવી: ${this.path}`);
  }

  // આ સિંક્રોનસ ડિસ્પોઝેબલ મેથડ છે
  [Symbol.dispose]() {
    console.log(`અસ્થાયી ફાઇલનો નિકાલ કરી રહ્યું છે: ${this.path}`);
    try {
      fs.unlinkSync(this.path);
      console.log('ફાઇલ સફળતાપૂર્વક કાઢી નાખવામાં આવી.');
    } catch (error) {
      console.error(`ફાઇલ કાઢી નાખવામાં નિષ્ફળ: ${this.path}`, error);
      // dispose ની અંદર પણ ભૂલોને હેન્ડલ કરવી મહત્વપૂર્ણ છે!
    }
  }
}

`TempFile` નો કોઈપણ ઇન્સ્ટન્સ હવે એક ડિસ્પોઝેબલ રિસોર્સ છે. તેની પાસે `Symbol.dispose` દ્વારા કી થયેલ એક મેથડ છે જેમાં ડિસ્કમાંથી ફાઇલને કાઢી નાખવાનો તર્ક છે.

Symbol.asyncDispose સાથે એસિંક્રોનસ ડિસ્પોઝલ

ઘણા આધુનિક ક્લિનઅપ ઓપરેશન્સ એસિંક્રોનસ હોય છે. ડેટાબેઝ કનેક્શન બંધ કરવામાં નેટવર્ક પર `QUIT` કમાન્ડ મોકલવાનો સમાવેશ થઈ શકે છે, અથવા મેસેજ ક્યૂ ક્લાયંટને તેના આઉટગોઇંગ બફરને ફ્લશ કરવાની જરૂર પડી શકે છે. આ દૃશ્યો માટે, આપણે `Symbol.asyncDispose` નો ઉપયોગ કરીએ છીએ.

`Symbol.asyncDispose` સાથે સંકળાયેલ મેથડે `Promise` રિટર્ન કરવું આવશ્યક છે (અથવા `async` ફંક્શન હોવું જોઈએ).

ચાલો એક મોક ડેટાબેઝ કનેક્શનનું મોડેલ બનાવીએ જેને એસિંક્રોનસલી પૂલમાં પાછું રિલીઝ કરવાની જરૂર છે.

// એક મોક ડેટાબેઝ પૂલ
const mockDbPool = {
  getConnection: () => {
    console.log('ડેટાબેઝ કનેક્શન પ્રાપ્ત થયું.');
    return new MockDbConnection();
  }
};

class MockDbConnection {
  query(sql) {
    console.log(`ક્વેરી એક્ઝેક્યુટ કરી રહ્યું છે: ${sql}`);
    return Promise.resolve({ success: true, rows: [] });
  }

  // આ એસિંક્રોનસ ડિસ્પોઝેબલ મેથડ છે
  async [Symbol.asyncDispose]() {
    console.log('ડેટાબેઝ કનેક્શનને પૂલમાં પાછું રિલીઝ કરી રહ્યું છે...');
    // કનેક્શન રિલીઝ કરવા માટે નેટવર્ક વિલંબનું અનુકરણ કરો
    await new Promise(resolve => setTimeout(resolve, 50));
    console.log('ડેટાબેઝ કનેક્શન રિલીઝ થયું.');
  }
}

હવે, કોઈપણ `MockDbConnection` ઇન્સ્ટન્સ એક એસિંક ડિસ્પોઝેબલ રિસોર્સ છે. જ્યારે તેની જરૂર ન હોય ત્યારે તે જાણે છે કે કેવી રીતે પોતાની જાતને એસિંક્રોનસલી રિલીઝ કરવી.

નવી સિન્ટેક્સ: using અને await using ક્રિયામાં

આપણા ડિસ્પોઝેબલ ક્લાસીસ વ્યાખ્યાયિત થવા સાથે, આપણે હવે તેમને આપમેળે સંચાલિત કરવા માટે નવા કીવર્ડ્સનો ઉપયોગ કરી શકીએ છીએ. આ કીવર્ડ્સ `let` અને `const` ની જેમ જ બ્લોક-સ્કોપ્ડ ઘોષણાઓ બનાવે છે.

using સાથે સિંક્રોનસ ક્લિનઅપ

`using` કીવર્ડ `Symbol.dispose` લાગુ કરનારા સંસાધનો માટે વપરાય છે. જ્યારે કોડ એક્ઝેક્યુશન `using` ઘોષણા કરાયેલા બ્લોકમાંથી બહાર નીકળે છે, ત્યારે `[Symbol.dispose]()` મેથડ આપમેળે કૉલ થાય છે.

ચાલો આપણી `TempFile` ક્લાસનો ઉપયોગ કરીએ:

function processDataWithTempFile() {
  console.log('બ્લોકમાં પ્રવેશી રહ્યું છે...');
  using tempFile = new TempFile('આ થોડો મહત્વપૂર્ણ ડેટા છે.');

  // તમે અહીં tempFile સાથે કામ કરી શકો છો
  const content = fs.readFileSync(tempFile.path, 'utf8');
  console.log(`અસ્થાયી ફાઇલમાંથી વાંચ્યું: "${content}"`);

  // અહીં કોઈ ક્લિનઅપ કોડની જરૂર નથી!
  console.log('...વધુ કામ કરી રહ્યું છે...');
} // <-- tempFile.[Symbol.dispose]() અહીં આપમેળે કૉલ થાય છે!

processDataWithTempFile();
console.log('બ્લોકમાંથી બહાર નીકળી ગયું છે.');

આઉટપુટ આ પ્રમાણે હશે:

બ્લોકમાં પ્રવેશી રહ્યું છે...
અસ્થાયી ફાઇલ બનાવી: /path/to/temp_1678886400000.txt
અસ્થાયી ફાઇલમાંથી વાંચ્યું: "આ થોડો મહત્વપૂર્ણ ડેટા છે."
...વધુ કામ કરી રહ્યું છે...
અસ્થાયી ફાઇલનો નિકાલ કરી રહ્યું છે: /path/to/temp_1678886400000.txt
ફાઇલ સફળતાપૂર્વક કાઢી નાખવામાં આવી.
બ્લોકમાંથી બહાર નીકળી ગયું છે.

જુઓ કે તે કેટલું સ્વચ્છ છે! રિસોર્સનું સમગ્ર જીવનચક્ર બ્લોકની અંદર સમાયેલું છે. આપણે તેને જાહેર કરીએ છીએ, તેનો ઉપયોગ કરીએ છીએ, અને તેના વિશે ભૂલી જઈએ છીએ. ભાષા ક્લિનઅપનું સંચાલન કરે છે. આ વાંચનીયતા અને સલામતીમાં એક મોટો સુધારો છે.

એકથી વધુ સંસાધનોનું સંચાલન

તમે એક જ બ્લોકમાં બહુવિધ `using` ઘોષણાઓ કરી શકો છો. તેમનો નિકાલ તેમની બનાવટના વિપરીત ક્રમમાં કરવામાં આવશે (LIFO અથવા "સ્ટેક-જેવી" વર્તણૂક).

{
  using resourceA = new MyDisposable('A'); // પ્રથમ બનાવ્યું
  using resourceB = new MyDisposable('B'); // બીજું બનાવ્યું
  console.log('બ્લોકની અંદર, સંસાધનોનો ઉપયોગ કરી રહ્યું છે...');
} // resourceB નો નિકાલ પ્રથમ થાય છે, પછી resourceA નો

await using સાથે એસિંક્રોનસ ક્લિનઅપ

`await using` કીવર્ડ `using` નો એસિંક્રોનસ સમકક્ષ છે. તે `Symbol.asyncDispose` લાગુ કરનારા સંસાધનો માટે વપરાય છે. કારણ કે ક્લિનઅપ એસિંક્રોનસ છે, આ કીવર્ડ ફક્ત `async` ફંક્શનની અંદર અથવા મોડ્યુલના ટોપ લેવલ પર (જો ટોપ-લેવલ await સપોર્ટેડ હોય તો) વાપરી શકાય છે.

ચાલો આપણી `MockDbConnection` ક્લાસનો ઉપયોગ કરીએ:

async function performDatabaseOperation() {
  console.log('એસિંક ફંક્શનમાં પ્રવેશી રહ્યું છે...');
  await using db = mockDbPool.getConnection();

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

  console.log('ડેટાબેઝ ઓપરેશન પૂર્ણ થયું.');
} // <-- await db.[Symbol.asyncDispose]() અહીં આપમેળે કૉલ થાય છે!

(async () => {
  await performDatabaseOperation();
  console.log('એસિંક ફંક્શન પૂર્ણ થયું છે.');
})();

આઉટપુટ એસિંક્રોનસ ક્લિનઅપ દર્શાવે છે:

એસિંક ફંક્શનમાં પ્રવેશી રહ્યું છે...
ડેટાબેઝ કનેક્શન પ્રાપ્ત થયું.
ક્વેરી એક્ઝેક્યુટ કરી રહ્યું છે: SELECT * FROM users
ડેટાબેઝ ઓપરેશન પૂર્ણ થયું.
ડેટાબેઝ કનેક્શનને પૂલમાં પાછું રિલીઝ કરી રહ્યું છે...
(50ms રાહ જુએ છે)
ડેટાબેઝ કનેક્શન રિલીઝ થયું.
એસિંક ફંક્શન પૂર્ણ થયું છે.

`using` ની જેમ જ, `await using` સિન્ટેક્સ સમગ્ર જીવનચક્રને સંભાળે છે, પરંતુ તે એસિંક્રોનસ ક્લિનઅપ પ્રક્રિયાને યોગ્ય રીતે `awaits` કરે છે. તે એવા સંસાધનોને પણ હેન્ડલ કરી શકે છે જે ફક્ત સિંક્રોનસલી ડિસ્પોઝેબલ હોય — તે ફક્ત તેમની રાહ જોશે નહીં.

અદ્યતન પેટર્ન: `DisposableStack` અને `AsyncDisposableStack`

ક્યારેક, `using` નું સરળ બ્લોક-સ્કોપિંગ પૂરતું લવચીક નથી. શું થાય જો તમારે સંસાધનોના સમૂહનું સંચાલન કરવાની જરૂર હોય જેનું જીવનકાળ એક જ લેક્સિકલ બ્લોક સાથે જોડાયેલું ન હોય? અથવા શું થાય જો તમે જૂની લાઇબ્રેરી સાથે સંકલન કરી રહ્યા હોવ જે `Symbol.dispose` વાળા ઓબ્જેક્ટ્સ ઉત્પન્ન કરતી નથી?

આ દૃશ્યો માટે, જાવાસ્ક્રિપ્ટ બે સહાયક ક્લાસીસ પ્રદાન કરે છે: `DisposableStack` અને `AsyncDisposableStack`.

`DisposableStack`: લવચીક ક્લિનઅપ મેનેજર

એક `DisposableStack` એ એક ઓબ્જેક્ટ છે જે ક્લિનઅપ ઓપરેશન્સના સંગ્રહનું સંચાલન કરે છે. તે પોતે જ એક ડિસ્પોઝેબલ રિસોર્સ છે, તેથી તમે તેના સમગ્ર જીવનચક્રને `using` બ્લોક સાથે સંચાલિત કરી શકો છો.

તેમાં ઘણી ઉપયોગી મેથડ્સ છે:

• .use(resource): સ્ટેકમાં `[Symbol.dispose]` મેથડ ધરાવતા ઓબ્જેક્ટને ઉમેરે છે. રિસોર્સ પરત કરે છે, જેથી તમે તેને ચેઇન કરી શકો.
• .defer(callback): સ્ટેકમાં એક મનસ્વી ક્લિનઅપ ફંક્શન ઉમેરે છે. આ એડ-હોક ક્લિનઅપ માટે અત્યંત ઉપયોગી છે.
• .adopt(value, callback): એક વેલ્યુ અને તે વેલ્યુ માટેનું ક્લિનઅપ ફંક્શન ઉમેરે છે. ડિસ્પોઝેબલ પ્રોટોકોલને સપોર્ટ ન કરતી લાઇબ્રેરીઓના સંસાધનોને રેપ કરવા માટે આ પરફેક્ટ છે.
• .move(): સંસાધનોની માલિકી નવા સ્ટેકમાં ટ્રાન્સફર કરે છે, વર્તમાનને સાફ કરે છે.

ઉદાહરણ: શરતી રિસોર્સ મેનેજમેન્ટ

એક ફંક્શનની કલ્પના કરો જે અમુક શરત પૂરી થાય તો જ લોગ ફાઇલ ખોલે છે, પરંતુ તમે ઇચ્છો છો કે બધું ક્લિનઅપ અંતે એક જ જગ્યાએ થાય.

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

  const db = stack.use(getDbConnection()); // હંમેશા ડેટાબેઝનો ઉપયોગ કરો

  if (shouldLog) {
    const logFileStream = fs.createWriteStream('app.log');
    // સ્ટ્રીમ માટે ક્લિનઅપને મુલતવી રાખો
    stack.defer(() => {
      console.log('લોગ ફાઇલ સ્ટ્રીમ બંધ કરી રહ્યું છે...');
      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('રિક્વેસ્ટ પ્રોસેસ કરી રહ્યું છે...');
  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('નિકાલ દરમિયાન ભૂલ!');
  }
}

try {
  using resource = new FaultyResource();
  throw new Error('ઓપરેશન દરમિયાન ભૂલ!');
} catch (e) {
  console.log(`પકડાયેલ ભૂલ: ${e.message}`); // ઓપરેશન દરમિયાન ભૂલ!
  if (e.suppressed) {
    console.log(`દબાયેલ ભૂલ: ${e.suppressed.message}`); // નિકાલ દરમિયાન ભૂલ!
    console.log(e instanceof SuppressedError); // false
    console.log(e.suppressed instanceof Error); // true
  }
}

આ વર્તણૂક સુનિશ્ચિત કરે છે કે તમે મૂળ નિષ્ફળતાનો સંદર્ભ ક્યારેય ગુમાવશો નહીં, જે વધુ મજબૂત અને ડિબગ કરી શકાય તેવી સિસ્ટમ્સ તરફ દોરી જાય છે.

જાવાસ્ક્રિપ્ટ ઇકોસિસ્ટમમાં વ્યવહારુ ઉપયોગના કિસ્સાઓ

એક્સપ્લિસિટ રિસોર્સ મેનેજમેન્ટના એપ્લિકેશન્સ વિશાળ છે અને વિશ્વભરના ડેવલપર્સ માટે સંબંધિત છે, પછી ભલે તેઓ બેક-એન્ડ, ફ્રન્ટ-એન્ડ, અથવા ટેસ્ટિંગમાં કામ કરતા હોય.

• બેક-એન્ડ (Node.js, Deno, Bun): સૌથી સ્પષ્ટ ઉપયોગના કિસ્સાઓ અહીં રહે છે. ડેટાબેઝ કનેક્શન્સ, ફાઇલ હેન્ડલ્સ, નેટવર્ક સોકેટ્સ, અને મેસેજ ક્યૂ ક્લાયન્ટ્સનું સંચાલન તુચ્છ અને સુરક્ષિત બને છે.
• ફ્રન્ટ-એન્ડ (વેબ બ્રાઉઝર્સ): ERM બ્રાઉઝરમાં પણ મૂલ્યવાન છે. તમે `WebSocket` કનેક્શન્સનું સંચાલન કરી શકો છો, વેબ લોક્સ API માંથી લોક્સ રિલીઝ કરી શકો છો, અથવા જટિલ WebRTC કનેક્શન્સ સાફ કરી શકો છો.
• ટેસ્ટિંગ ફ્રેમવર્ક (Jest, Mocha, etc.): મોક્સ, સ્પાઇસ, ટેસ્ટ સર્વર્સ, અથવા ડેટાબેઝ સ્ટેટ્સને આપમેળે તોડવા માટે `beforeEach` માં અથવા ટેસ્ટની અંદર `DisposableStack` નો ઉપયોગ કરો, જે સ્વચ્છ ટેસ્ટ આઇસોલેશન સુનિશ્ચિત કરે છે.
• UI ફ્રેમવર્ક (React, Svelte, Vue): જ્યારે આ ફ્રેમવર્કમાં તેમની પોતાની જીવનચક્ર પદ્ધતિઓ હોય છે, ત્યારે તમે ઇવેન્ટ લિસનર્સ અથવા તૃતીય-પક્ષ લાઇબ્રેરી સબ્સ્ક્રિપ્શન્સ જેવા નોન-ફ્રેમવર્ક સંસાધનોનું સંચાલન કરવા માટે કમ્પોનન્ટની અંદર `DisposableStack` નો ઉપયોગ કરી શકો છો, જેથી ખાતરી કરી શકાય કે તેઓ બધા અનમાઉન્ટ પર સાફ થઈ જાય.

બ્રાઉઝર અને રનટાઇમ સપોર્ટ

એક આધુનિક ફીચર તરીકે, એ જાણવું અગત્યનું છે કે તમે એક્સપ્લિસિટ રિસોર્સ મેનેજમેન્ટનો ઉપયોગ ક્યાં કરી શકો છો. 2023 ના અંતમાં / 2024 ની શરૂઆતમાં, મુખ્ય જાવાસ્ક્રિપ્ટ પર્યાવરણોના નવીનતમ સંસ્કરણોમાં સપોર્ટ વ્યાપક છે:

• Node.js: સંસ્કરણ 20+ (પહેલાના સંસ્કરણોમાં ફ્લેગ પાછળ)
• Deno: સંસ્કરણ 1.32+
• Bun: સંસ્કરણ 1.0+
• બ્રાઉઝર્સ: Chrome 119+, Firefox 121+, Safari 17.2+

જૂના પર્યાવરણો માટે, તમારે `using` સિન્ટેક્સને ટ્રાન્સફોર્મ કરવા અને જરૂરી સિમ્બોલ્સ અને સ્ટેક ક્લાસીસને પોલીફિલ કરવા માટે Babel જેવા ટ્રાન્સપાઈલર્સ પર યોગ્ય પ્લગઇન્સ સાથે આધાર રાખવો પડશે.

નિષ્કર્ષ: સલામતી અને સ્પષ્ટતાનો નવો યુગ

જાવાસ્ક્રિપ્ટનું એક્સપ્લિસિટ રિસોર્સ મેનેજમેન્ટ માત્ર સિન્ટેક્ટિક શુગર કરતાં વધુ છે; તે ભાષામાં એક મૂળભૂત સુધારો છે જે સલામતી, સ્પષ્ટતા અને જાળવણીક્ષમતાને પ્રોત્સાહન આપે છે. રિસોર્સ ક્લિનઅપની કંટાળાજનક અને ભૂલ-સંભવિત પ્રક્રિયાને સ્વચાલિત કરીને, તે ડેવલપર્સને તેમના પ્રાથમિક બિઝનેસ લોજિક પર ધ્યાન કેન્દ્રિત કરવા માટે મુક્ત કરે છે.

મુખ્ય તારણો છે:

• ક્લિનઅપને સ્વચાલિત કરો: મેન્યુઅલ try...finally બોઈલરપ્લેટને દૂર કરવા માટે using અને await using નો ઉપયોગ કરો.
• વાંચનીયતામાં સુધારો કરો: રિસોર્સ પ્રાપ્તિ અને તેના જીવનચક્રના સ્કોપને ચુસ્તપણે જોડાયેલા અને દૃશ્યમાન રાખો.
• લીક્સ અટકાવો: ખાતરી આપો કે ક્લિનઅપ લોજિક એક્ઝેક્યુટ થાય છે, જે તમારી એપ્લિકેશન્સમાં ખર્ચાળ રિસોર્સ લીક્સને અટકાવે છે.
• ભૂલોને મજબૂત રીતે હેન્ડલ કરો: નવા SuppressedError મિકેનિઝમનો લાભ લો જેથી ક્યારેય મહત્વપૂર્ણ ભૂલનો સંદર્ભ ન ગુમાવો.

જ્યારે તમે નવા પ્રોજેક્ટ્સ શરૂ કરો અથવા હાલના કોડને રિફેક્ટર કરો, ત્યારે આ શક્તિશાળી નવી પેટર્ન અપનાવવાનું વિચારો. તે તમારા જાવાસ્ક્રિપ્ટને સ્વચ્છ બનાવશે, તમારી એપ્લિકેશન્સને વધુ વિશ્વસનીય બનાવશે, અને ડેવલપર તરીકે તમારું જીવન થોડું સરળ બનાવશે. આ આધુનિક, પ્રોફેશનલ જાવાસ્ક્રિપ્ટ લખવા માટેનું સાચું વૈશ્વિક ધોરણ છે.