ஜாவாஸ்கிரிப்ட் ஒத்திசைவு வடிவங்கள்: ப்ராமிஸ் பூல்கள் மற்றும் விகித வரம்பு

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

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

ஜாவாஸ்கிரிப்ட், அதன் இயல்பிலேயே, ஒற்றை-திரிக்கப்பட்டது (single-threaded). இதன் பொருள் ஒரே நேரத்தில் ஒரு செயல்பாடு மட்டுமே இயங்க முடியும். இருப்பினும், ஒத்திசைவற்ற செயல்பாடுகளின் அறிமுகம் (கால்பேக்குகள், ப்ராமிஸ்கள், மற்றும் async/await போன்ற நுட்பங்களைப் பயன்படுத்தி) ஜாவாஸ்கிரிப்டை பிரதான திரியைத் தடுக்காமல் ஒரே நேரத்தில் பல பணிகளைக் கையாள அனுமதிக்கிறது. இந்த சூழலில், ஒத்திசைவு என்பது ஒரே நேரத்தில் பல பணிகளை நிர்வகிப்பதைக் குறிக்கிறது.

இந்தச் சூழ்நிலைகளைக் கவனியுங்கள்:

• ஒரு டாஷ்போர்டை நிரப்புவதற்காக ஒரே நேரத்தில் பல APIகளிலிருந்து தரவைப் பெறுதல்.
• ஒரு தொகுப்பில் அதிக எண்ணிக்கையிலான படங்களைச் செயலாக்குதல்.
• டேட்டாபேஸ் தொடர்புகள் தேவைப்படும் பல பயனர் கோரிக்கைகளைக் கையாளுதல்.

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

ப்ராமிஸ் பூல்கள்: ஒரே நேரத்தில் இயங்கும் பணிகளை நிர்வகித்தல்

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

ஒரு ப்ராமிஸ் பூலை செயல்படுத்துதல்

ஜாவாஸ்கிரிப்டில் ஒரு ப்ராமிஸ் பூலின் அடிப்படைச் செயல்பாடு இதோ:

            
class PromisePool {
  constructor(concurrency) {
    this.concurrency = concurrency;
    this.running = 0;
    this.queue = [];
  }

  async add(task) {
    return new Promise((resolve, reject) => {
      this.queue.push({ task, resolve, reject });
      this.processQueue();
    });
  }

  async processQueue() {
    if (this.running < this.concurrency && this.queue.length) {
      const { task, resolve, reject } = this.queue.shift();
      this.running++;

      try {
        const result = await task();
        resolve(result);
      } catch (error) {
        reject(error);
      } finally {
        this.running--;
        this.processQueue(); // Process the next task in the queue
      }
    }
  }
}

            

              
                Copy
              
            
          

விளக்கம்:

• PromisePool கிளாஸ் ஒரு concurrency அளவுருவை எடுத்துக்கொள்கிறது, இது ஒரே நேரத்தில் இயங்கக்கூடிய பணிகளின் அதிகபட்ச எண்ணிக்கையை வரையறுக்கிறது.
• add முறை ஒரு பணியை (ஒரு ப்ராமிஸைத் தரும் ஒரு செயல்பாடு) வரிசையில் சேர்க்கிறது. அது ஒரு ப்ராமிஸைத் திருப்பி அளிக்கிறது, அது பணி முடிந்ததும் resolve அல்லது reject ஆகும்.
• processQueue முறை, கிடைக்கும் இடங்கள் (this.running < this.concurrency) மற்றும் வரிசையில் பணிகள் உள்ளதா எனச் சரிபார்க்கிறது. அவ்வாறு இருந்தால், அது வரிசையிலிருந்து ஒரு பணியை எடுத்து, அதை இயக்கி, running எண்ணியைப் புதுப்பிக்கிறது.
• finally பகுதி, பணி தோல்வியடைந்தாலும், running எண்ணி குறைக்கப்படுவதையும், வரிசையில் உள்ள அடுத்த பணியைச் செயலாக்க processQueue முறை மீண்டும் அழைக்கப்படுவதையும் உறுதிசெய்கிறது.

எடுத்துக்காட்டு பயன்பாடு

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

            
async function fetchData(url) {
  console.log(`Fetching data from ${url}`);
  // Simulate network latency
  await new Promise(resolve => setTimeout(resolve, Math.random() * 1000));
  const response = await fetch(url);
  if (!response.ok) {
    throw new Error(`HTTP error! status: ${response.status}`);
  }
  return await response.json();
}

async function main() {
  const urls = [
    'https://jsonplaceholder.typicode.com/todos/1',
    'https://jsonplaceholder.typicode.com/todos/2',
    'https://jsonplaceholder.typicode.com/todos/3',
    'https://jsonplaceholder.typicode.com/todos/4',
    'https://jsonplaceholder.typicode.com/todos/5',
    'https://jsonplaceholder.typicode.com/todos/6',
    'https://jsonplaceholder.typicode.com/todos/7',
    'https://jsonplaceholder.typicode.com/todos/8',
    'https://jsonplaceholder.typicode.com/todos/9',
    'https://jsonplaceholder.typicode.com/todos/10',
  ];

  const pool = new PromisePool(3); // Limit concurrency to 3
  const promises = urls.map(url => pool.add(() => fetchData(url)));

  try {
    const results = await Promise.all(promises);
    console.log('Results:', results);
  } catch (error) {
    console.error('Error fetching data:', error);
  }
}

main();

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், PromisePool 3 ஒத்திசைவு மதிப்புடன் கட்டமைக்கப்பட்டுள்ளது. urls.map செயல்பாடு ப்ராமிஸ்களின் ஒரு வரிசையை உருவாக்குகிறது, ஒவ்வொன்றும் ஒரு குறிப்பிட்ட URL-லிருந்து தரவைப் பெறுவதற்கான ஒரு பணியைக் குறிக்கிறது. pool.add முறை ஒவ்வொரு பணியையும் ப்ராமிஸ் பூலில் சேர்க்கிறது, இது இந்த பணிகளின் செயல்பாட்டை ஒரே நேரத்தில் நிர்வகிக்கிறது, எந்த நேரத்திலும் 3-க்கும் மேற்பட்ட கோரிக்கைகள் செயல்பாட்டில் இல்லை என்பதை உறுதி செய்கிறது. Promise.all செயல்பாடு அனைத்து பணிகளும் முடிவடையும் வரை காத்திருந்து, முடிவுகளின் ஒரு வரிசையைத் திருப்பி அளிக்கிறது.

விகித வரம்பு: API துஷ்பிரயோகம் மற்றும் சேவை அதிக சுமைகளைத் தடுத்தல்

விகித வரம்பு என்பது கிளையண்டுகள் (அல்லது பயனர்கள்) ஒரு சேவை அல்லது API-க்கு கோரிக்கைகளை அனுப்பும் விகிதத்தைக் கட்டுப்படுத்தும் ஒரு நுட்பமாகும். இது துஷ்பிரயோகத்தைத் தடுக்கவும், சேவை மறுப்பு (DoS) தாக்குதல்களுக்கு எதிராகப் பாதுகாக்கவும், வளங்களின் நியாயமான பயன்பாட்டை உறுதிப்படுத்தவும் அவசியம். விகித வரம்பை கிளையன்ட்-பக்கம், சேவையக-பக்கம் அல்லது இரண்டிலும் செயல்படுத்தலாம்.

விகித வரம்பை ஏன் பயன்படுத்த வேண்டும்?

• துஷ்பிரயோகத்தைத் தடுத்தல்: ஒரு குறிப்பிட்ட காலப்பகுதியில் ஒரு பயனர் அல்லது கிளையன்ட் செய்யக்கூடிய கோரிக்கைகளின் எண்ணிக்கையைக் கட்டுப்படுத்துகிறது, இது அவர்களை அதிகப்படியான கோரிக்கைகளுடன் சேவையகத்தை மூழ்கடிப்பதில் இருந்து தடுக்கிறது.
• DoS தாக்குதல்களுக்கு எதிராகப் பாதுகாத்தல்: தாக்குபவர்கள் கோரிக்கைகளை அனுப்பும் விகிதத்தைக் கட்டுப்படுத்துவதன் மூலம் விநியோகிக்கப்பட்ட சேவை மறுப்பு (DDoS) தாக்குதல்களின் தாக்கத்தைக் குறைக்க உதவுகிறது.
• நியாயமான பயன்பாட்டை உறுதிசெய்தல்: கோரிக்கைகளை சமமாக விநியோகிப்பதன் மூலம் வெவ்வேறு பயனர்கள் அல்லது கிளையண்டுகள் வளங்களை நியாயமாக அணுக அனுமதிக்கிறது.
• செயல்திறனை மேம்படுத்துதல்: சேவையகம் அதிக சுமையுடன் இருப்பதைத் தடுக்கிறது, இது கோரிக்கைகளுக்கு சரியான நேரத்தில் பதிலளிக்க முடியும் என்பதை உறுதி செய்கிறது.
• செலவு மேம்படுத்தல்: API பயன்பாட்டு ஒதுக்கீடுகளை மீறும் அபாயத்தைக் குறைத்து, மூன்றாம் தரப்பு சேவைகளிலிருந்து கூடுதல் செலவுகள் ஏற்படுவதைத் தடுக்கிறது.

ஜாவாஸ்கிரிப்டில் விகித வரம்பை செயல்படுத்துதல்

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

            
class RateLimiter {
  constructor(capacity, refillRate, interval) {
    this.capacity = capacity; // Maximum number of tokens
    this.tokens = capacity;
    this.refillRate = refillRate; // Tokens added per interval
    this.interval = interval; // Interval in milliseconds

    setInterval(() => {
      this.refill();
    }, this.interval);
  }

  refill() {
    this.tokens = Math.min(this.capacity, this.tokens + this.refillRate);
  }

  async consume(cost = 1) {
    if (this.tokens >= cost) {
      this.tokens -= cost;
      return Promise.resolve();
    } else {
      return new Promise((resolve, reject) => {
        const waitTime = Math.ceil((cost - this.tokens) / this.refillRate) * this.interval;
        setTimeout(() => {
          if (this.tokens >= cost) {
            this.tokens -= cost;
            resolve();
          } else {
            reject(new Error('Rate limit exceeded.'));
          }
        }, waitTime);
      });
    }
  }
}

            

              
                Copy
              
            
          

விளக்கம்:

• RateLimiter கிளாஸ் மூன்று அளவுருக்களை எடுத்துக்கொள்கிறது: capacity (டோக்கன்களின் அதிகபட்ச எண்ணிக்கை), refillRate (ஒரு இடைவெளியில் சேர்க்கப்படும் டோக்கன்களின் எண்ணிக்கை), மற்றும் interval (மில்லி விநாடிகளில் நேர இடைவெளி).
• refill முறை, interval ஒன்றுக்கு refillRate என்ற விகிதத்தில், அதிகபட்ச கொள்ளளவு வரை பக்கெட்டில் டோக்கன்களைச் சேர்க்கிறது.
• consume முறை குறிப்பிட்ட எண்ணிக்கையிலான டோக்கன்களை (இயல்பாக 1) பயன்படுத்த முயற்சிக்கிறது. போதுமான டோக்கன்கள் இருந்தால், அது அவற்றை பயன்படுத்தி உடனடியாக resolve செய்கிறது. இல்லையெனில், போதுமான டோக்கன்கள் கிடைக்கும் வரை காத்திருக்க வேண்டிய நேரத்தைக் கணக்கிட்டு, அந்த நேரம் வரை காத்திருந்து, பின்னர் மீண்டும் டோக்கன்களைப் பயன்படுத்த முயற்சிக்கிறது. அப்போதும் போதுமான டோக்கன்கள் இல்லையென்றால், அது ஒரு பிழையுடன் reject செய்கிறது.

எடுத்துக்காட்டு பயன்பாடு

            
async function makeApiRequest() {
  // Simulate API request
  await new Promise(resolve => setTimeout(resolve, Math.random() * 500));
  console.log('API request successful');
}

async function main() {
  const rateLimiter = new RateLimiter(5, 1, 1000); // 5 requests per second

  for (let i = 0; i < 10; i++) {
    try {
      await rateLimiter.consume();
      await makeApiRequest();
    } catch (error) {
      console.error('Rate limit exceeded:', error.message);
    }
  }
}

main();

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், RateLimiter வினாடிக்கு 5 கோரிக்கைகளை அனுமதிக்குமாறு கட்டமைக்கப்பட்டுள்ளது. main செயல்பாடு 10 API கோரிக்கைகளைச் செய்கிறது, ஒவ்வொன்றும் rateLimiter.consume() அழைப்பிற்கு முன் செய்யப்படுகிறது. விகித வரம்பை மீறினால், consume முறை ஒரு பிழையுடன் reject செய்யும், இது try...catch பகுதி மூலம் பிடிக்கப்படுகிறது.

ப்ராமிஸ் பூல்கள் மற்றும் விகித வரம்பை இணைத்தல்

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

இந்த இரண்டு வடிவங்களையும் நீங்கள் எவ்வாறு இணைக்கலாம் என்பது இங்கே:

            
async function fetchDataWithRateLimit(url, rateLimiter) {
  try {
    await rateLimiter.consume();
    return await fetchData(url);
  } catch (error) {
    throw error;
  }
}

async function main() {
  const urls = [
    'https://jsonplaceholder.typicode.com/todos/1',
    'https://jsonplaceholder.typicode.com/todos/2',
    'https://jsonplaceholder.typicode.com/todos/3',
    'https://jsonplaceholder.typicode.com/todos/4',
    'https://jsonplaceholder.typicode.com/todos/5',
    'https://jsonplaceholder.typicode.com/todos/6',
    'https://jsonplaceholder.typicode.com/todos/7',
    'https://jsonplaceholder.typicode.com/todos/8',
    'https://jsonplaceholder.typicode.com/todos/9',
    'https://jsonplaceholder.typicode.com/todos/10',
  ];

  const pool = new PromisePool(3); // Limit concurrency to 3
  const rateLimiter = new RateLimiter(5, 1, 1000); // 5 requests per second

  const promises = urls.map(url => pool.add(() => fetchDataWithRateLimit(url, rateLimiter)));

  try {
    const results = await Promise.all(promises);
    console.log('Results:', results);
  } catch (error) {
    console.error('Error fetching data:', error);
  }
}

main();

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், fetchDataWithRateLimit செயல்பாடு URL-லிருந்து தரவைப் பெறுவதற்கு முன்பு RateLimiter-இலிருந்து ஒரு டோக்கனைப் பயன்படுத்துகிறது. இது PromisePool மூலம் நிர்வகிக்கப்படும் ஒத்திசைவு அளவைப் பொருட்படுத்தாமல், கோரிக்கை விகிதம் கட்டுப்படுத்தப்படுவதை உறுதி செய்கிறது.

உலகளாவிய பயன்பாடுகளுக்கான பரிசீலனைகள்

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

• நேர மண்டலங்கள்: விகித வரம்பைச் செயல்படுத்தும்போது நேர மண்டலங்களைக் கவனத்தில் கொள்ள வேண்டும். உங்கள் விகித வரம்பு தர்க்கம் ஒரு நிலையான நேர மண்டலத்தை அடிப்படையாகக் கொண்டிருப்பதை உறுதிசெய்யுங்கள் அல்லது நேர மண்டலம்-சாராத அணுகுமுறையைப் பயன்படுத்தவும் (எ.கா., UTC).
• புவியியல் விநியோகம்: உங்கள் பயன்பாடு பல புவியியல் பகுதிகளில் பயன்படுத்தப்பட்டால், நெட்வொர்க் தாமதம் மற்றும் பயனர் நடத்தையில் உள்ள வேறுபாடுகளைக் கணக்கில் கொள்ள, ஒவ்வொரு பகுதிக்கும் விகித வரம்பைச் செயல்படுத்துவதைக் கருத்தில் கொள்ளுங்கள். உள்ளடக்க விநியோக நெட்வொர்க்குகள் (CDNs) பெரும்பாலும் விளிம்பில் கட்டமைக்கக்கூடிய விகித வரம்பு அம்சங்களை வழங்குகின்றன.
• API வழங்குநர் விகித வரம்புகள்: உங்கள் பயன்பாடு பயன்படுத்தும் மூன்றாம் தரப்பு API-கள் விதிக்கும் விகித வரம்புகளை அறிந்திருங்கள். இந்த வரம்புகளுக்குள் இருக்கவும், தடுக்கப்படுவதைத் தவிர்க்கவும் உங்கள் சொந்த விகித வரம்பு தர்க்கத்தைச் செயல்படுத்தவும். விகித வரம்பு பிழைகளை நேர்த்தியாகக் கையாள, ஜிட்டருடன் கூடிய எக்ஸ்போனென்ஷியல் பேக்ஆஃப் பயன்படுத்துவதைக் கருத்தில் கொள்ளுங்கள்.
• பயனர் அனுபவம்: பயனர்கள் விகித வரம்புக்கு உட்படுத்தப்படும்போது, வரம்புக்கான காரணத்தையும், எதிர்காலத்தில் அதை எவ்வாறு தவிர்ப்பது என்பதையும் விளக்கி, தகவல் தரும் பிழைச் செய்திகளை வழங்கவும். வெவ்வேறு பயனர் தேவைகளுக்கு இடமளிக்க, மாறுபட்ட விகித வரம்புகளுடன் வெவ்வேறு சேவை அடுக்குகளை வழங்குவதைக் கருத்தில் கொள்ளுங்கள்.
• கண்காணிப்பு மற்றும் பதிவு செய்தல்: உங்கள் பயன்பாட்டின் ஒத்திசைவு மற்றும் கோரிக்கை விகிதங்களைக் கண்காணித்து, சாத்தியமான தடைகளைக் கண்டறிந்து, உங்கள் விகித வரம்பு தர்க்கம் திறம்பட செயல்படுவதை உறுதிசெய்யுங்கள். பயன்பாட்டு முறைகளைக் கண்காணிக்கவும், சாத்தியமான துஷ்பிரயோகத்தைக் கண்டறியவும் தொடர்புடைய அளவீடுகளைப் பதிவு செய்யுங்கள்.

முடிவுரை

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

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