ஜாவாஸ்கிரிப்ட் அசிங்க் இட்டரேட்டர் வள மேலாண்மை: ஸ்ட்ரீம் சுத்திகரிப்பு ஆட்டோமேஷன்

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

அசிங்க் இட்டரேட்டர்கள் மற்றும் ஜெனரேட்டர்களைப் புரிந்துகொள்ளுதல்

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

அசிங்க் இட்டரேட்டர்கள்

ஒரு அசிங்க் இட்டரேட்டர் என்பது ஒரு ஆப்ஜெக்ட் ஆகும், இது ஒரு next() முறையை வரையறுக்கிறது, இது இரண்டு பண்புகளைக் கொண்ட ஒரு ஆப்ஜெக்ட்டுக்குத் தீர்க்கும் ஒரு ப்ராமிஸை வழங்குகிறது:

• value: வரிசையில் அடுத்த மதிப்பு.
• done: இட்டரேட்டர் முடிந்துவிட்டதா என்பதைக் குறிக்கும் ஒரு பூலியன்.

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

உதாரணம்:

async function* asyncIterable() {
  yield 1;
  yield 2;
  yield 3;
}

async function main() {
  for await (const value of asyncIterable()) {
    console.log(value);
  }
}

main(); // வெளியீடு: 1, 2, 3

அசிங்க் ஜெனரேட்டர்கள்

அசிங்க் ஜெனரேட்டர்கள் என்பவை அசிங்க் இட்டரேட்டர்களை வழங்கும் செயல்பாடுகள் ஆகும். அவை async function* தொடரியல் மற்றும் yield முக்கியச் சொல்லைப் பயன்படுத்தி மதிப்புகளை ஒத்திசைவற்ற முறையில் உருவாக்குகின்றன.

உதாரணம்:

async function* generateSequence(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 500)); // ஒத்திசைவற்ற செயல்பாட்டை உருவகப்படுத்துங்கள்
    yield i;
  }
}

async function main() {
  for await (const value of generateSequence(1, 5)) {
    console.log(value);
  }
}

main(); // வெளியீடு: 1, 2, 3, 4, 5 (ஒவ்வொரு மதிப்பிற்கும் இடையில் 500ms தாமதத்துடன்)

சவால்: ஒத்திசைவற்ற ஸ்ட்ரீம்களில் வள மேலாண்மை

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

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

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

ஸ்ட்ரீம் சுத்திகரிப்பை தானியங்குபடுத்துதல்: நுட்பங்கள் மற்றும் சிறந்த நடைமுறைகள்

அசிங்க் இட்டரேட்டர்களில் வள மேலாண்மை சவால்களை எதிர்கொள்ள, ஸ்ட்ரீம் சுத்திகரிப்பை தானியங்குபடுத்த பல நுட்பங்களைப் பயன்படுத்தலாம்.

1. try...finally பிளாக்

try...finally பிளாக் என்பது வள சுத்திகரிப்பை உறுதி செய்வதற்கான ஒரு அடிப்படைக் பொறிமுறையாகும். try பிளாக்கில் பிழை ஏற்பட்டதா இல்லையா என்பதைப் பொருட்படுத்தாமல், finally பிளாக் எப்போதும் செயல்படுத்தப்படும்.

உதாரணம்:

async function* readFileLines(filePath) {
  let fileHandle;
  try {
    fileHandle = await fs.open(filePath, 'r');
    const stream = fileHandle.readableWebStream();
    const reader = stream.getReader();
    let decoder = new TextDecoder();

    while (true) {
      const { done, value } = await reader.read();
      if (done) {
        break;
      }
      yield decoder.decode(value);
    }
  } finally {
    if (fileHandle) {
      await fileHandle.close();
      console.log('கோப்பு கைப்பிடி மூடப்பட்டது.');
    }
  }
}

async function main() {
  try{
    for await (const line of readFileLines('example.txt')) {
      console.log(line);
    }
  } catch (error) {
    console.error('கோப்பைப் படிப்பதில் பிழை:', error);
  }
}

main();

இந்த எடுத்துக்காட்டில், கோப்பைப் படிக்கும்போது பிழை ஏற்பட்டாலும், கோப்பு கைப்பிடி எப்போதும் மூடப்படுவதை finally பிளாக் உறுதி செய்கிறது.

2. Symbol.asyncDispose பயன்படுத்துதல் (வெளிப்படையான வள மேலாண்மை முன்மொழிவு)

வெளிப்படையான வள மேலாண்மை முன்மொழிவு Symbol.asyncDispose சின்னத்தை அறிமுகப்படுத்துகிறது, இது ஒரு ஆப்ஜெக்ட் இனி தேவைப்படாதபோது தானாக அழைக்கப்படும் ஒரு முறையை வரையறுக்க ஆப்ஜெக்ட்களை அனுமதிக்கிறது. இது C#-ல் using அறிக்கை அல்லது ஜாவாவில் try-with-resources அறிக்கை போன்றது.

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

தற்போதைய சூழல்களில் இதைப் பயன்படுத்த பாலிஃபில்கள் கிடைக்கின்றன.

உதாரணம் (ஒரு கற்பனையான பாலிஃபில்லைப் பயன்படுத்தி):

import { using } from 'resource-management-polyfill';

class MyResource {
  constructor() {
    console.log('வளம் பெறப்பட்டது.');
  }

  async [Symbol.asyncDispose]() {
    await new Promise(resolve => setTimeout(resolve, 100)); // அசிங்க் சுத்திகரிப்பை உருவகப்படுத்துங்கள்
    console.log('வளம் வெளியிடப்பட்டது.');
  }
}

async function main() {
  await using(new MyResource(), async (resource) => {
    console.log('வளத்தைப் பயன்படுத்துகிறது...');
    // ... வளத்தைப் பயன்படுத்தவும்
  }); // வளம் இங்கே தானாகவே அகற்றப்படுகிறது
  console.log('பயன்படுத்திய பிளாக்கிற்குப் பிறகு.');
}

main();

இந்த எடுத்துக்காட்டில், using அறிக்கை, பிழை ஏற்பட்டதா இல்லையா என்பதைப் பொருட்படுத்தாமல், பிளாக் வெளியேறும்போது MyResource ஆப்ஜெக்ட்டின் [Symbol.asyncDispose] முறை அழைக்கப்படுவதை உறுதி செய்கிறது. இது வளங்களை வெளியிட ஒரு தீர்மானகரமான மற்றும் நம்பகமான வழியை வழங்குகிறது.

3. ஒரு ரிசோர்ஸ் ராப்பரை செயல்படுத்துதல்

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

உதாரணம்:

class FileStreamResource {
  constructor(filePath) {
    this.filePath = filePath;
    this.fileHandle = null;
  }

  async acquire() {
    this.fileHandle = await fs.open(this.filePath, 'r');
    console.log('கோப்பு கைப்பிடி பெறப்பட்டது.');
    return this.fileHandle.readableWebStream();
  }

  async release() {
    if (this.fileHandle) {
      await this.fileHandle.close();
      console.log('கோப்பு கைப்பிடி வெளியிடப்பட்டது.');
      this.fileHandle = null;
    }
  }
}

async function* readFileLines(resource) {
  try {
    const stream = await resource.acquire();
    const reader = stream.getReader();
    let decoder = new TextDecoder();

    while (true) {
      const { done, value } = await reader.read();
      if (done) {
        break;
      }
      yield decoder.decode(value);
    }
  } finally {
    await resource.release();
  }
}

async function main() {
  const fileResource = new FileStreamResource('example.txt');
  try {
    for await (const line of readFileLines(fileResource)) {
      console.log(line);
    }
  } catch (error) {
    console.error('கோப்பைப் படிப்பதில் பிழை:', error);
  }
}

main();

இந்த எடுத்துக்காட்டில், FileStreamResource வகுப்பு கோப்பு கைப்பிடி மற்றும் அதன் சுத்திகரிப்பு தர்க்கத்தை உள்ளடக்கியது. readFileLines ஜெனரேட்டர் இந்த வகுப்பைப் பயன்படுத்தி, பிழை ஏற்பட்டாலும், கோப்பு கைப்பிடி எப்போதும் வெளியிடப்படுவதை உறுதி செய்கிறது.

4. லைப்ரரிகள் மற்றும் ஃபிரேம்வொர்க்குகளைப் பயன்படுத்துதல்

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

• Node.js Streams API: Node.js Streams API ஸ்ட்ரீமிங் தரவைக் கையாள ஒரு வலுவான மற்றும் திறமையான வழியை வழங்குகிறது. இது பின்னடைவை நிர்வகிப்பதற்கும் சரியான சுத்திகரிப்பை உறுதி செய்வதற்கும் பொறிமுறைகளைக் கொண்டுள்ளது.
• RxJS (Reactive Extensions for JavaScript): RxJS என்பது எதிர்வினை நிரலாக்கத்திற்கான ஒரு நூலகமாகும், இது ஒத்திசைவற்ற தரவு ஸ்ட்ரீம்களை நிர்வகிப்பதற்கான சக்திவாய்ந்த கருவிகளை வழங்குகிறது. இது பிழைகளைக் கையாளுதல், செயல்பாடுகளை மீண்டும் முயற்சித்தல் மற்றும் வள சுத்திகரிப்பை உறுதி செய்தல் ஆகியவற்றிற்கான ஆபரேட்டர்களைக் கொண்டுள்ளது.
• தானியங்கு-சுத்திகரிப்புடன் கூடிய லைப்ரரிகள்: சில தரவுத்தள மற்றும் நெட்வொர்க்கிங் லைப்ரரிகள் தானியங்கி இணைப்பு பூலிங் மற்றும் வள வெளியீட்டுடன் வடிவமைக்கப்பட்டுள்ளன.

உதாரணம் (Node.js Streams API-ஐப் பயன்படுத்தி):

const fs = require('node:fs');
const { pipeline } = require('node:stream/promises');
const { Transform } = require('node:stream');

async function main() {
  try {
    await pipeline(
      fs.createReadStream('example.txt'),
      new Transform({
        transform(chunk, encoding, callback) {
          this.push(chunk.toString().toUpperCase());
          callback();
        }
      }),
      fs.createWriteStream('output.txt')
    );
    console.log('பைப்லைன் வெற்றி பெற்றது.');
  } catch (err) {
    console.error('பைப்லைன் தோல்வியடைந்தது.', err);
  }
}

main();

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

வள மேலாண்மைக்கான மேம்பட்ட நுட்பங்கள்

அடிப்படை நுட்பங்களுக்கு அப்பால், பல மேம்பட்ட உத்திகள் அசிங்க் இட்டரேட்டர்களில் வள மேலாண்மையை மேலும் மேம்படுத்தலாம்.

1. ரத்துசெய்யும் டோக்கன்கள்

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

உதாரணம்:

class CancellationToken {
  constructor() {
    this.isCancelled = false;
    this.listeners = [];
  }

  cancel() {
    this.isCancelled = true;
    for (const listener of this.listeners) {
      listener();
    }
  }

  register(listener) {
    this.listeners.push(listener);
    return () => {
      this.listeners = this.listeners.filter(l => l !== listener);
    };
  }
}

async function* fetchData(url, cancellationToken) {
  try {
    const response = await fetch(url);
    if (!response.ok) {
      throw new Error(`HTTP பிழை! நிலை: ${response.status}`);
    }

    const reader = response.body.getReader();
    const decoder = new TextDecoder();

    while (true) {
      if (cancellationToken.isCancelled) {
        console.log('பெறுதல் ரத்து செய்யப்பட்டது.');
        reader.cancel(); // ஸ்ட்ரீமை ரத்து செய்
        return;
      }

      const { done, value } = await reader.read();
      if (done) {
        break;
      }

      yield decoder.decode(value);
    }
  } catch (error) {
    console.error('தரவைப் பெறுவதில் பிழை:', error);
  }
}

async function main() {
  const cancellationToken = new CancellationToken();
  const url = 'https://example.com/data'; // ஒரு சரியான URL உடன் மாற்றவும்

  setTimeout(() => {
    cancellationToken.cancel(); // 3 வினாடிகளுக்குப் பிறகு ரத்து செய்
  }, 3000);

  try {
    for await (const chunk of fetchData(url, cancellationToken)) {
      console.log(chunk);
    }
  } catch (error) {
    console.error('தரவைச் செயலாக்குவதில் பிழை:', error);
  }
}

main();

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

2. WeakRefs மற்றும் FinalizationRegistry

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

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

உதாரணம்:

const registry = new FinalizationRegistry(heldValue => {
  console.log(`சுத்திகரிப்பு: ${heldValue}`);
  // இங்கே சுத்திகரிப்பு செய்யவும் (எ.கா., இணைப்புகளை மூடவும்)
});

class MyObject {
  constructor(id) {
    this.id = id;
    registry.register(this, `Object ${id}`, this);
  }
}

let obj1 = new MyObject(1);
let obj2 = new MyObject(2);

// ... பின்னர், obj1 மற்றும் obj2 இனி குறிப்பிடப்படாவிட்டால்:
// obj1 = null;
// obj2 = null;
// குப்பை சேகரிப்பு இறுதியில் FinalizationRegistry-ஐத் தூண்டும்
// மற்றும் சுத்திகரிப்பு செய்தி பதிவு செய்யப்படும்.

3. பிழை எல்லைகள் மற்றும் மீட்பு

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

உதாரணம்:

async function* processData(dataStream) {
  try {
    for await (const data of dataStream) {
      try {
        // செயலாக்கத்தின் போது ஏற்படக்கூடிய பிழையை உருவகப்படுத்துங்கள்
        if (Math.random() < 0.1) {
          throw new Error('செயலாக்கப் பிழை!');
        }
        yield `Processed: ${data}`;
      } catch (error) {
        console.error('தரவைச் செயலாக்குவதில் பிழை:', error);
        // சிக்கலான தரவை மீட்டெடுக்கவும் அல்லது தவிர்க்கவும்
        yield `Error: ${error.message}`;
      }
    }
  } catch (error) {
    console.error('ஸ்ட்ரீம் பிழை:', error);
    // ஸ்ட்ரீம் பிழையைக் கையாளவும் (எ.கா., பதிவு, நிறுத்துதல்)
  }
}

async function* generateData() {
  for (let i = 0; i < 10; i++) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield `Data ${i}`;
  }
}

async function main() {
  for await (const result of processData(generateData())) {
    console.log(result);
  }
}

main();

நிஜ-உலக உதாரணங்கள் மற்றும் பயன்பாட்டு வழக்குகள்

தானியங்குபடுத்தப்பட்ட ஸ்ட்ரீம் சுத்திகரிப்பு முக்கியமான சில நிஜ-உலக உதாரணங்கள் மற்றும் பயன்பாட்டு வழக்குகளை ஆராய்வோம்.

1. பெரிய கோப்புகளை ஸ்ட்ரீமிங் செய்தல்

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

உதாரணம் (ஒரு பெரிய CSV கோப்பைப் படித்து செயலாக்குதல்):

const fs = require('node:fs');
const readline = require('node:readline');

async function processLargeCSV(filePath) {
  const fileStream = fs.createReadStream(filePath);
  const rl = readline.createInterface({
    input: fileStream,
    crlfDelay: Infinity
  });

  try {
    for await (const line of rl) {
      // CSV கோப்பின் ஒவ்வொரு வரியையும் செயலாக்கவும்
      console.log(`செயலாக்கப்படுகிறது: ${line}`);
    }
  } finally {
    fileStream.close(); // கோப்பு ஸ்ட்ரீம் மூடப்பட்டிருப்பதை உறுதிசெய்யவும்
    console.log('கோப்பு ஸ்ட்ரீம் மூடப்பட்டது.');
  }
}

async function main() {
  try{
    await processLargeCSV('large_data.csv');
  } catch (error) {
    console.error('CSV செயலாக்கத்தில் பிழை:', error);
  }
}

main();

2. தரவுத்தள இணைப்புகளைக் கையாளுதல்

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

உதாரணம் (ஒரு தரவுத்தளத்திலிருந்து தரவைப் பெற்று இணைப்பை மூடுதல்):

const { Pool } = require('pg');

async function fetchDataFromDatabase(query) {
  const pool = new Pool({
    user: 'dbuser',
    host: 'localhost',
    database: 'mydb',
    password: 'dbpassword',
    port: 5432
  });

  let client;

  try {
    client = await pool.connect();
    const result = await client.query(query);
    return result.rows;
  } finally {
    if (client) {
      client.release(); // இணைப்பை மீண்டும் பூலுக்கு விடுவிக்கவும்
      console.log('தரவுத்தள இணைப்பு வெளியிடப்பட்டது.');
    }
  }
}

async function main() {
  try{
    const data = await fetchDataFromDatabase('SELECT * FROM mytable');
    console.log('தரவு:', data);
  } catch (error) {
    console.error('தரவைப் பெறுவதில் பிழை:', error);
  }
}

main();

3. நெட்வொர்க் ஸ்ட்ரீம்களைச் செயலாக்குதல்

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

உதாரணம் (ஒரு தொலைநிலை API-இலிருந்து தரவைப் பெற்று இணைப்பை மூடுதல்):

const https = require('node:https');

async function fetchDataFromAPI(url) {
  return new Promise((resolve, reject) => {
    const req = https.get(url, (res) => {
      let data = '';

      res.on('data', (chunk) => {
        data += chunk;
      });

      res.on('end', () => {
        resolve(JSON.parse(data));
      });
    });

    req.on('error', (error) => {
      reject(error);
    });

    req.on('close', () => {
      console.log('இணைப்பு மூடப்பட்டது.');
    });
  });
}

async function main() {
  try {
    const data = await fetchDataFromAPI('https://jsonplaceholder.typicode.com/todos/1');
    console.log('தரவு:', data);
  } catch (error) {
    console.error('தரவைப் பெறுவதில் பிழை:', error);
  }
}

main();

முடிவுரை

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

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

மேலும் கற்றல்

• அசிங்க் இட்டரேட்டர்கள் மற்றும் ஜெனரேட்டர்கள் குறித்த MDN வலை ஆவணங்கள்: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for-await...of
• Node.js Streams API ஆவணம்: https://nodejs.org/api/stream.html
• RxJS ஆவணம்: https://rxjs.dev/
• வெளிப்படையான வள மேலாண்மை முன்மொழிவு: https://github.com/tc39/proposal-explicit-resource-management

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