ஜாவாஸ்கிரிப்ட் அசிங்க் கான்டெக்ஸ்ட்: கோரிக்கை-சார்ந்த மாறிகளின் மேலாண்மையில் தேர்ச்சி பெறுதல்

ஒத்திசைவற்ற நிரலாக்கம் (Asynchronous programming) நவீன ஜாவாஸ்கிரிப்ட் மேம்பாட்டின் ஒரு மூலக்கல்லாகும், குறிப்பாக Node.js போன்ற சூழல்களில். இருப்பினும், ஒத்திசைவற்ற செயல்பாடுகளுக்கு இடையில் கான்டெக்ஸ்ட் (context) மற்றும் கோரிக்கை-சார்ந்த மாறிகளை (request-scoped variables) நிர்வகிப்பது சவாலானது. பாரம்பரிய அணுகுமுறைகள் பெரும்பாலும் சிக்கலான குறியீடு மற்றும் சாத்தியமான தரவு சிதைவுக்கு வழிவகுக்கின்றன. இந்தக் கட்டுரை ஜாவாஸ்கிரிப்ட்டின் ஒத்திசைவற்ற கான்டெக்ஸ்ட் திறன்களை, குறிப்பாக AsyncLocalStorage மீது கவனம் செலுத்தி, வலுவான மற்றும் அளவிடக்கூடிய பயன்பாடுகளை உருவாக்குவதற்கான கோரிக்கை-சார்ந்த மாறி மேலாண்மையை அது எவ்வாறு எளிதாக்குகிறது என்பதை ஆராய்கிறது.

ஒத்திசைவற்ற கான்டெக்ஸ்டின் சவால்களைப் புரிந்துகொள்ளுதல்

ஒத்திசைவான நிரலாக்கத்தில் (synchronous programming), ஒரு செயல்பாட்டின் எல்லைக்குள் மாறிகளை நிர்வகிப்பது எளிதானது. ஒவ்வொரு செயல்பாட்டிற்கும் அதன் சொந்த செயலாக்கச் சூழல் (execution context) உள்ளது, மேலும் அந்தச் சூழலில் அறிவிக்கப்பட்ட மாறிகள் தனிமைப்படுத்தப்படுகின்றன. இருப்பினும், ஒத்திசைவற்ற செயல்பாடுகள் நேரியல் ரீதியாகச் செயல்படாததால் அவை சிக்கல்களை அறிமுகப்படுத்துகின்றன. கால்பேக்குகள் (Callbacks), ப்ராமிஸ்கள் (promises), மற்றும் அசிங்க்/அவெயிட் (async/await) ஆகியவை புதிய செயலாக்கச் சூழல்களை அறிமுகப்படுத்துகின்றன, இது ஒரு குறிப்பிட்ட கோரிக்கை அல்லது செயல்பாட்டிற்கு தொடர்பான மாறிகளைப் பராமரிப்பதையும் அணுகுவதையும் கடினமாக்குகிறது.

ஒரு கோரிக்கை கையாளரின் (request handler) செயல்பாடு முழுவதும் ஒரு தனித்துவமான கோரிக்கை ஐடியை (request ID) நீங்கள் கண்காணிக்க வேண்டிய ஒரு சூழ்நிலையைக் கவனியுங்கள். சரியான பொறிமுறை இல்லாமல், கோரிக்கையைச் செயலாக்குவதில் ஈடுபட்டுள்ள ஒவ்வொரு செயல்பாட்டிற்கும் கோரிக்கை ஐடியை ஒரு வாதமாக (argument) அனுப்ப வேண்டியிருக்கும். இந்த அணுகுமுறை சிரமமானது, பிழை ஏற்பட வாய்ப்புள்ளது, மற்றும் உங்கள் குறியீட்டை இறுக்கமாக இணைக்கிறது.

கான்டெக்ஸ்ட் பரவலின் சிக்கல்

• குறியீட்டுக் குழப்பம்: பல செயல்பாட்டு அழைப்புகள் மூலம் கான்டெக்ஸ்ட் மாறிகளை அனுப்புவது குறியீட்டின் சிக்கலை கணிசமாக அதிகரித்து, வாசிப்புத்திறனைக் குறைக்கிறது.
• இறுக்கமான இணைப்பு: செயல்பாடுகள் குறிப்பிட்ட கான்டெக்ஸ்ட் மாறிகளைச் சார்ந்து இருப்பதால், அவற்றை மீண்டும் பயன்படுத்துவதும் சோதிப்பதும் கடினமாகிறது.
• பிழைக்கு வாய்ப்புள்ளது: ஒரு கான்டெக்ஸ்ட் மாறியை அனுப்ப மறப்பது அல்லது தவறான மதிப்பை அனுப்புவது கணிக்க முடியாத நடத்தைக்கும், பிழைதிருத்தம் செய்யக் கடினமான சிக்கல்களுக்கும் வழிவகுக்கும்.
• பராமரிப்புச் சுமை: கான்டெக்ஸ்ட் மாறிகளில் மாற்றங்கள் செய்தால், குறியீட்டுத் தளத்தின் பல பகுதிகளில் மாற்றங்கள் தேவைப்படும்.

இந்தச் சவால்கள், ஒத்திசைவற்ற ஜாவாஸ்கிரிப்ட் சூழல்களில் கோரிக்கை-சார்ந்த மாறிகளை நிர்வகிப்பதற்கு ஒரு நேர்த்தியான மற்றும் வலுவான தீர்வுக்கான தேவையை எடுத்துக்காட்டுகின்றன.

AsyncLocalStorage அறிமுகம்: அசிங்க் கான்டெக்ஸுக்கான ஒரு தீர்வு

Node.js v14.5.0-ல் அறிமுகப்படுத்தப்பட்ட AsyncLocalStorage, ஒரு ஒத்திசைவற்ற செயல்பாட்டின் ஆயுட்காலம் முழுவதும் தரவைச் சேமிப்பதற்கான ஒரு பொறிமுறையை வழங்குகிறது. இது அடிப்படையில் ஒத்திசைவற்ற எல்லைகளுக்கு அப்பாலும் நீடித்திருக்கும் ஒரு கான்டெக்ஸை உருவாக்குகிறது, இது ஒரு குறிப்பிட்ட கோரிக்கை அல்லது செயல்பாட்டிற்குரிய மாறிகளை வெளிப்படையாக அனுப்பாமல் அணுகவும் மாற்றவும் உங்களை அனுமதிக்கிறது.

AsyncLocalStorage ஒவ்வொரு செயலாக்கச் சூழலின் (per-execution context) அடிப்படையிலும் செயல்படுகிறது. ஒவ்வொரு ஒத்திசைவற்ற செயல்பாடும் (எ.கா., ஒரு கோரிக்கை கையாளர்) அதன் சொந்த தனிமைப்படுத்தப்பட்ட சேமிப்பிடத்தைப் பெறுகிறது. இது ஒரு கோரிக்கையுடன் தொடர்புடைய தரவு தற்செயலாக மற்றொரு கோரிக்கைக்குள் கசியாமல் இருப்பதை உறுதிசெய்து, தரவு ஒருமைப்பாட்டையும் தனிமைப்படுத்தலையும் பராமரிக்கிறது.

AsyncLocalStorage எவ்வாறு செயல்படுகிறது

AsyncLocalStorage வகுப்பு பின்வரும் முக்கிய மெத்தட்களை (methods) வழங்குகிறது:

• getStore(): தற்போதைய செயலாக்கச் சூழலுடன் தொடர்புடைய தற்போதைய ஸ்டோரை (store) வழங்குகிறது. ஸ்டோர் இல்லை என்றால், இது undefined ஐ வழங்கும்.
• run(store, callback, ...args): வழங்கப்பட்ட callback-ஐ ஒரு புதிய ஒத்திசைவற்ற கான்டெக்ஸுக்குள் செயல்படுத்துகிறது. store என்ற ஆர்குமென்ட் கான்டெக்ஸ்டின் சேமிப்பகத்தைத் துவக்குகிறது. கால்பேக்கினால் தூண்டப்படும் அனைத்து ஒத்திசைவற்ற செயல்பாடுகளுக்கும் இந்த ஸ்டோருக்கான அணுகல் இருக்கும்.
• enterWith(store): வழங்கப்பட்ட store-இன் கான்டெக்ஸுக்குள் நுழைகிறது. ஒரு குறிப்பிட்ட குறியீட்டுத் தொகுதிக்கு கான்டெக்ஸை வெளிப்படையாக அமைக்க வேண்டியிருக்கும் போது இது பயனுள்ளதாக இருக்கும்.
• disable(): AsyncLocalStorage இன்ஸ்டன்ஸை முடக்குகிறது. முடக்கிய பிறகு ஸ்டோரை அணுகினால் பிழை ஏற்படும்.

ஸ்டோர் என்பது நீங்கள் நிர்வகிக்க விரும்பும் கான்டெக்ஸ்ட் மாறிகளைக் கொண்டிருக்கும் ஒரு எளிய ஜாவாஸ்கிரிப்ட் ஆப்ஜெக்ட் (அல்லது நீங்கள் தேர்ந்தெடுக்கும் எந்த தரவு வகை) ஆகும். நீங்கள் கோரிக்கை ஐடிகள், பயனர் தகவல், அல்லது தற்போதைய செயல்பாட்டிற்குத் தொடர்புடைய வேறு எந்தத் தரவையும் சேமிக்கலாம்.

AsyncLocalStorage செயல்பாட்டில் உள்ள நடைமுறை எடுத்துக்காட்டுகள்

AsyncLocalStorage-இன் பயன்பாட்டை பல நடைமுறை எடுத்துக்காட்டுகளுடன் விளக்குவோம்.

எடுத்துக்காட்டு 1: ஒரு வலை சேவையகத்தில் கோரிக்கை ஐடி கண்காணிப்பு

Express.js-ஐப் பயன்படுத்தும் ஒரு Node.js வலை சேவையகத்தைக் கவனியுங்கள். ஒவ்வொரு உள்வரும் கோரிக்கைக்கும் ஒரு தனித்துவமான கோரிக்கை ஐடியை தானாக உருவாக்கி கண்காணிக்க விரும்புகிறோம். இந்த ஐடி பதிவு செய்தல், தடமறிதல் மற்றும் பிழைதிருத்தம் ஆகியவற்றிற்குப் பயன்படுத்தப்படலாம்.

const express = require('express');
const { AsyncLocalStorage } = require('async_hooks');
const { v4: uuidv4 } = require('uuid');

const app = express();
const asyncLocalStorage = new AsyncLocalStorage();

app.use((req, res, next) => {
  const requestId = uuidv4();
  asyncLocalStorage.run(new Map(), () => {
    asyncLocalStorage.getStore().set('requestId', requestId);
    console.log(`Request received with ID: ${requestId}`);
    next();
  });
});

app.get('/', (req, res) => {
  const requestId = asyncLocalStorage.getStore().get('requestId');
  console.log(`Handling request with ID: ${requestId}`);
  res.send(`Hello, Request ID: ${requestId}`);
});

app.listen(3000, () => {
  console.log('Server listening on port 3000');
});

இந்த எடுத்துக்காட்டில்:

• நாம் ஒரு AsyncLocalStorage இன்ஸ்டன்ஸை உருவாக்குகிறோம்.
• ஒவ்வொரு உள்வரும் கோரிக்கையையும் இடைமறிக்க எக்ஸ்பிரஸ் மிடில்வேரைப் பயன்படுத்துகிறோம்.
• மிடில்வேருக்குள், uuidv4()-ஐப் பயன்படுத்தி ஒரு தனித்துவமான கோரிக்கை ஐடியை உருவாக்குகிறோம்.
• ஒரு புதிய ஒத்திசைவற்ற கான்டெக்ஸை உருவாக்க asyncLocalStorage.run()-ஐ அழைக்கிறோம். எங்கள் கான்டெக்ஸ்ட் மாறிகளைக் கொண்டிருக்கும் Map உடன் ஸ்டோரைத் துவக்குகிறோம்.
• run() கால்பேக்கின் உள்ளே, asyncLocalStorage.getStore().set('requestId', requestId)-ஐப் பயன்படுத்தி ஸ்டோரில் requestId-ஐ அமைக்கிறோம்.
• பின்னர் அடுத்த மிடில்வேர் அல்லது ரூட் ஹேண்ட்லருக்கு கட்டுப்பாட்டைக் கொடுக்க next()-ஐ அழைக்கிறோம்.
• ரூட் ஹேண்ட்லரில் (app.get('/')), asyncLocalStorage.getStore().get('requestId')-ஐப் பயன்படுத்தி ஸ்டோரிலிருந்து requestId-ஐப் பெறுகிறோம்.

இப்போது, கோரிக்கை கையாளருக்குள் எத்தனை ஒத்திசைவற்ற செயல்பாடுகள் தூண்டப்பட்டாலும், நீங்கள் எப்போதும் asyncLocalStorage.getStore().get('requestId')-ஐப் பயன்படுத்தி கோரிக்கை ஐடியை அணுகலாம்.

எடுத்துக்காட்டு 2: பயனர் அங்கீகாரம் மற்றும் அதிகாரமளித்தல்

பயனர் அங்கீகாரம் மற்றும் அதிகாரமளித்தல் தகவல்களை நிர்வகிப்பது மற்றொரு பொதுவான பயன்பாட்டு வழக்காகும். ஒரு பயனரை அங்கீகரித்து அவர்களின் பயனர் ஐடியைப் பெறும் மிடில்வேர் உங்களிடம் உள்ளது என்று வைத்துக்கொள்வோம். நீங்கள் பயனர் ஐடியை AsyncLocalStorage-இல் சேமிக்கலாம், இதனால் அது அடுத்தடுத்த மிடில்வேர் மற்றும் ரூட் ஹேண்ட்லர்களுக்குக் கிடைக்கும்.

const express = require('express');
const { AsyncLocalStorage } = require('async_hooks');

const app = express();
const asyncLocalStorage = new AsyncLocalStorage();

// Authentication Middleware (Example)
const authenticateUser = (req, res, next) => {
  // Simulate user authentication (replace with your actual logic)
  const userId = req.headers['x-user-id'] || 'guest'; // Get User ID from Header

  asyncLocalStorage.run(new Map(), () => {
    asyncLocalStorage.getStore().set('userId', userId);
    console.log(`User authenticated with ID: ${userId}`);
    next();
  });
};

app.use(authenticateUser);

app.get('/profile', (req, res) => {
  const userId = asyncLocalStorage.getStore().get('userId');
  console.log(`Accessing profile for user ID: ${userId}`);
  res.send(`Profile for User ID: ${userId}`);
});

app.listen(3000, () => {
  console.log('Server listening on port 3000');
});

இந்த எடுத்துக்காட்டில், authenticateUser மிடில்வேர் பயனர் ஐடியை (இங்கே ஒரு ஹெட்டரைப் படிப்பதன் மூலம் உருவகப்படுத்தப்பட்டது) பெற்று அதை AsyncLocalStorage-இல் சேமிக்கிறது. /profile ரூட் ஹேண்ட்லர் பின்னர் பயனர் ஐடியை ஒரு வெளிப்படையான அளவுருவாகப் பெறாமல் அணுக முடியும்.

எடுத்துக்காட்டு 3: தரவுத்தள பரிவர்த்தனை மேலாண்மை

தரவுத்தள பரிவர்த்தனைகளை உள்ளடக்கிய சூழ்நிலைகளில், பரிவர்த்தனை கான்டெக்ஸை நிர்வகிக்க AsyncLocalStorage பயன்படுத்தப்படலாம். நீங்கள் தரவுத்தள இணைப்பு அல்லது பரிவர்த்தனை ஆப்ஜெக்டை AsyncLocalStorage-இல் சேமிக்கலாம், இது ஒரு குறிப்பிட்ட கோரிக்கைக்குள் உள்ள அனைத்து தரவுத்தள செயல்பாடுகளும் ஒரே பரிவர்த்தனையைப் பயன்படுத்துவதை உறுதி செய்கிறது.

const express = require('express');
const { AsyncLocalStorage } = require('async_hooks');

const app = express();
const asyncLocalStorage = new AsyncLocalStorage();

// Simulate a database connection
const db = {
  query: (sql, callback) => {
    const transactionId = asyncLocalStorage.getStore()?.get('transactionId') || 'No Transaction';
    console.log(`Executing SQL: ${sql} in Transaction: ${transactionId}`);
    // Simulate database query execution
    setTimeout(() => {
      callback(null, { success: true });
    }, 50);
  },
};

// Middleware to start a transaction
const startTransaction = (req, res, next) => {
  const transactionId = Math.random().toString(36).substring(2, 15); // Generate a random transaction ID

  asyncLocalStorage.run(new Map(), () => {
    asyncLocalStorage.getStore().set('transactionId', transactionId);
    console.log(`Starting transaction: ${transactionId}`);
    next();
  });
};

app.use(startTransaction);

app.get('/data', (req, res) => {
  db.query('SELECT * FROM data', (err, result) => {
    if (err) {
      return res.status(500).send('Error querying data');
    }
    res.send('Data retrieved successfully');
  });
});

app.listen(3000, () => {
  console.log('Server listening on port 3000');
});

இந்த எளிமைப்படுத்தப்பட்ட எடுத்துக்காட்டில்:

• startTransaction மிடில்வேர் ஒரு பரிவர்த்தனை ஐடியை உருவாக்கி அதை AsyncLocalStorage-இல் சேமிக்கிறது.
• உருவகப்படுத்தப்பட்ட db.query செயல்பாடு ஸ்டோரிலிருந்து பரிவர்த்தனை ஐடியைப் பெற்று அதைப் பதிவுசெய்கிறது, இது ஒத்திசைவற்ற தரவுத்தள செயல்பாட்டிற்குள் பரிவர்த்தனை கான்டெக்ஸ்ட் கிடைப்பதைக் காட்டுகிறது.

மேம்பட்ட பயன்பாடு மற்றும் பரிசீலனைகள்

மிடில்வேர் மற்றும் கான்டெக்ஸ்ட் பரவல்

AsyncLocalStorage மிடில்வேர் சங்கிலிகளில் குறிப்பாக பயனுள்ளதாக இருக்கும். ஒவ்வொரு மிடில்வேரும் பகிரப்பட்ட கான்டெக்ஸை அணுகலாம் மற்றும் மாற்றியமைக்கலாம், இது சிக்கலான செயலாக்கப் பைப்லைன்களை எளிதாக உருவாக்க உங்களை அனுமதிக்கிறது.

உங்கள் மிடில்வேர் செயல்பாடுகள் கான்டெக்ஸை சரியாகப் பரப்புவதற்கு வடிவமைக்கப்பட்டுள்ளதை உறுதிப்படுத்தவும். ஒத்திசைவற்ற செயல்பாடுகளைச் சுற்றி asyncLocalStorage.run() அல்லது asyncLocalStorage.enterWith()-ஐப் பயன்படுத்தி கான்டெக்ஸ்ட் ஓட்டத்தைப் பராமரிக்கவும்.

பிழை கையாளுதல் மற்றும் சுத்தம் செய்தல்

AsyncLocalStorage-ஐப் பயன்படுத்தும் போது சரியான பிழை கையாளுதல் முக்கியமானது. விதிவிலக்குகளை நீங்கள் நேர்த்தியாகக் கையாள்வதையும், கான்டெக்ஸுடன் தொடர்புடைய எந்த வளங்களையும் சுத்தம் செய்வதையும் உறுதிப்படுத்திக் கொள்ளுங்கள். ஒரு பிழை ஏற்பட்டாலும் வளங்கள் விடுவிக்கப்படுவதை உறுதிப்படுத்த try...finally பிளாக்குகளைப் பயன்படுத்துவதைக் கவனியுங்கள்.

செயல்திறன் பரிசீலனைகள்

AsyncLocalStorage கான்டெக்ஸை நிர்வகிக்க ஒரு வசதியான வழியை வழங்கினாலும், அதன் செயல்திறன் தாக்கங்கள் குறித்து கவனமாக இருப்பது அவசியம். AsyncLocalStorage-இன் அதிகப்படியான பயன்பாடு, குறிப்பாக அதிக செயல்திறன் கொண்ட பயன்பாடுகளில், கூடுதல் சுமையை அறிமுகப்படுத்தக்கூடும். சாத்தியமான தடைகளைக் கண்டறிந்து அதற்கேற்ப மேம்படுத்த உங்கள் குறியீட்டை சுயவிவரம் செய்யவும்.

AsyncLocalStorage-இல் அதிக அளவு தரவைச் சேமிப்பதைத் தவிர்க்கவும். தேவையான கான்டெக்ஸ்ட் மாறிகளை மட்டுமே சேமிக்கவும். நீங்கள் பெரிய ஆப்ஜெக்டுகளை சேமிக்க வேண்டுமானால், ஆப்ஜெக்டுகளுக்குப் பதிலாக அவற்றின் குறிப்புகளைச் சேமிப்பதைக் கவனியுங்கள்.

AsyncLocalStorage-க்கு மாற்றுகள்

AsyncLocalStorage ஒரு சக்திவாய்ந்த கருவியாக இருந்தாலும், உங்கள் குறிப்பிட்ட தேவைகள் மற்றும் கட்டமைப்பைப் பொறுத்து, ஒத்திசைவற்ற கான்டெக்ஸை நிர்வகிப்பதற்கான மாற்று அணுகுமுறைகள் உள்ளன.

• வெளிப்படையான கான்டெக்ஸ்ட் அனுப்புதல்: முன்னர் குறிப்பிட்டபடி, கான்டெக்ஸ்ட் மாறிகளை செயல்பாடுகளுக்கு வாதங்களாக வெளிப்படையாக அனுப்புவது ஒரு அடிப்படை, ஆனால் நேர்த்தியற்ற அணுகுமுறையாகும்.
• கான்டெக்ஸ்ட் ஆப்ஜெக்டுகள்: ஒரு பிரத்யேக கான்டெக்ஸ்ட் ஆப்ஜெக்டை உருவாக்கி அதைச் சுற்றி அனுப்புவது தனிப்பட்ட மாறிகளை அனுப்புவதை விட வாசிப்புத்திறனை மேம்படுத்தும்.
• கட்டமைப்பு-சார்ந்த தீர்வுகள்: பல கட்டமைப்புகள் அவற்றின் சொந்த கான்டெக்ஸ்ட் மேலாண்மை வழிமுறைகளை வழங்குகின்றன. எடுத்துக்காட்டாக, NestJS கோரிக்கை-சார்ந்த வழங்குநர்களை வழங்குகிறது.

உலகளாவிய பார்வை மற்றும் சிறந்த நடைமுறைகள்

ஒரு உலகளாவிய சூழலில் ஒத்திசைவற்ற கான்டெக்ஸுடன் பணிபுரியும்போது, பின்வருவனவற்றைக் கவனியுங்கள்:

• நேர மண்டலங்கள்: கான்டெக்ஸில் தேதி மற்றும் நேரத் தகவல்களைக் கையாளும் போது நேர மண்டலங்கள் குறித்து கவனமாக இருங்கள். தெளிவின்மையைத் தவிர்க்க நேர முத்திரைகளுடன் நேர மண்டலத் தகவலைச் சேமிக்கவும்.
• உள்ளூர்மயமாக்கல்: உங்கள் பயன்பாடு பல மொழிகளை ஆதரித்தால், உள்ளடக்கம் சரியான மொழியில் காட்டப்படுவதை உறுதிசெய்ய, பயனரின் உள்ளூர் அமைப்பை கான்டெக்ஸில் சேமிக்கவும்.
• நாணயம்: உங்கள் பயன்பாடு நிதி பரிவர்த்தனைகளைக் கையாண்டால், தொகைகள் சரியாகக் காட்டப்படுவதை உறுதிசெய்ய, பயனரின் நாணயத்தை கான்டெக்ஸில் சேமிக்கவும்.
• தரவு வடிவங்கள்: வெவ்வேறு பிராந்தியங்களில் பயன்படுத்தப்படும் வெவ்வேறு தரவு வடிவங்கள் குறித்து எச்சரிக்கையாக இருங்கள். எடுத்துக்காட்டாக, தேதி வடிவங்கள் மற்றும் எண் வடிவங்கள் கணிசமாக வேறுபடலாம்.

முடிவுரை

ஒத்திசைவற்ற ஜாவாஸ்கிரிப்ட் சூழல்களில் கோரிக்கை-சார்ந்த மாறிகளை நிர்வகிப்பதற்கு AsyncLocalStorage ஒரு சக்திவாய்ந்த மற்றும் நேர்த்தியான தீர்வை வழங்குகிறது. ஒத்திசைவற்ற எல்லைகளுக்கு அப்பால் ஒரு நீடித்த கான்டெக்ஸை உருவாக்குவதன் மூலம், இது குறியீட்டை எளிதாக்குகிறது, இணைப்பைக் குறைக்கிறது மற்றும் பராமரிப்புத்திறனை மேம்படுத்துகிறது. அதன் திறன்கள் மற்றும் வரம்புகளைப் புரிந்துகொள்வதன் மூலம், வலுவான, அளவிடக்கூடிய மற்றும் உலகளவில் அறிந்த பயன்பாடுகளை உருவாக்க நீங்கள் AsyncLocalStorage-ஐப் பயன்படுத்தலாம்.

ஒத்திசைவற்ற குறியீட்டுடன் பணிபுரியும் எந்த ஜாவாஸ்கிரிப்ட் டெவலப்பருக்கும் ஒத்திசைவற்ற கான்டெக்ஸில் தேர்ச்சி பெறுவது அவசியம். தூய்மையான, மேலும் பராமரிக்கக்கூடிய மற்றும் மேலும் நம்பகமான பயன்பாடுகளை எழுத AsyncLocalStorage மற்றும் பிற கான்டெக்ஸ்ட் மேலாண்மை நுட்பங்களைத் தழுவுங்கள்.