జావాస్క్రిప్ట్ అసింక్ ఇటరేటర్ రిసోర్స్ మేనేజ్‌మెంట్: స్ట్రీమ్ క్లీనప్ ఆటోమేషన్

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

అసింక్ ఇటరేటర్లు మరియు జెనరేటర్లను అర్థం చేసుకోవడం

రిసోర్స్ మేనేజ్‌మెంట్‌లోకి ప్రవేశించే ముందు, అసింక్ ఇటరేటర్లు మరియు జెనరేటర్ల యొక్క ప్రాథమికాలను సమీక్షిద్దాం.

అసింక్ ఇటరేటర్లు

ఒక అసింక్ ఇటరేటర్ అనేది ఒక ఆబ్జెక్ట్, ఇది 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('File handle closed.');
    }
  }
}

async function main() {
  try{
    for await (const line of readFileLines('example.txt')) {
      console.log(line);
    }
  } catch (error) {
    console.error('Error reading file:', error);
  }
}

main();

ఈ ఉదాహరణలో, ఫైల్‌ను చదివేటప్పుడు లోపం సంభవించినప్పటికీ, ఫైల్ హ్యాండిల్ ఎల్లప్పుడూ మూసివేయబడుతుందని finally బ్లాక్ నిర్ధారిస్తుంది.

2. Symbol.asyncDisposeను ఉపయోగించడం (ఎక్స్‌ప్లిసిట్ రిసోర్స్ మేనేజ్‌మెంట్ ప్రపోజల్)

ఎక్స్‌ప్లిసిట్ రిసోర్స్ మేనేజ్‌మెంట్ ప్రపోజల్ Symbol.asyncDispose సింబల్‌ను పరిచయం చేస్తుంది, ఇది ఆబ్జెక్ట్‌లు ఇకపై అవసరం లేనప్పుడు ఆటోమేటిక్‌గా పిలవబడే ఒక మెథడ్‌ను నిర్వచించడానికి అనుమతిస్తుంది. ఇది C# లోని using స్టేట్‌మెంట్ లేదా జావాలోని try-with-resources స్టేట్‌మెంట్‌కు సమానంగా ఉంటుంది.

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

ప్రస్తుత వాతావరణాలలో దీనిని ఉపయోగించడానికి పాలిఫిల్స్ అందుబాటులో ఉన్నాయి.

ఉదాహరణ (ఒక ఊహాజనిత పాలిఫిల్ ఉపయోగించి):

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

class MyResource {
  constructor() {
    console.log('Resource acquired.');
  }

  async [Symbol.asyncDispose]() {
    await new Promise(resolve => setTimeout(resolve, 100)); // అసింక్ క్లీనప్‌ను అనుకరించండి
    console.log('Resource released.');
  }
}

async function main() {
  await using(new MyResource(), async (resource) => {
    console.log('Using resource...');
    // ... వనరును ఉపయోగించండి
  }); // వనరు ఇక్కడ ఆటోమేటిక్‌గా డిస్పోజ్ చేయబడుతుంది
  console.log('After using block.');
}

main();

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

3. ఒక రిసోర్స్ వ్రాపర్‌ను అమలు చేయడం

మరొక విధానం ఏమిటంటే, వనరును మరియు దాని క్లీనప్ లాజిక్‌ను చుట్టి ఉంచే ఒక రిసోర్స్ వ్రాపర్ క్లాస్‌ను సృష్టించడం. ఈ క్లాస్ వనరును సంపాదించడం మరియు విడుదల చేయడం కోసం మెథడ్‌లను అమలు చేయగలదు, క్లీనప్ ఎల్లప్పుడూ సరిగ్గా నిర్వహించబడుతుందని నిర్ధారిస్తుంది.

ఉదాహరణ:

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

  async acquire() {
    this.fileHandle = await fs.open(this.filePath, 'r');
    console.log('File handle acquired.');
    return this.fileHandle.readableWebStream();
  }

  async release() {
    if (this.fileHandle) {
      await this.fileHandle.close();
      console.log('File handle released.');
      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 reading file:', error);
  }
}

main();

ఈ ఉదాహరణలో, FileStreamResource క్లాస్ ఫైల్ హ్యాండిల్ మరియు దాని క్లీనప్ లాజిక్‌ను చుట్టి ఉంచుతుంది. readFileLines జెనరేటర్ ఈ క్లాస్‌ను ఉపయోగించి ఫైల్ హ్యాండిల్ ఎల్లప్పుడూ విడుదల చేయబడుతుందని నిర్ధారిస్తుంది, లోపం సంభవించినప్పటికీ.

4. లైబ్రరీలు మరియు ఫ్రేమ్‌వర్క్‌లను ఉపయోగించుకోవడం

చాలా లైబ్రరీలు మరియు ఫ్రేమ్‌వర్క్‌లు రిసోర్స్ మేనేజ్‌మెంట్ మరియు స్ట్రీమ్ క్లీనప్ కోసం అంతర్నిర్మిత యంత్రాంగాలను అందిస్తాయి. ఇవి ప్రక్రియను సులభతరం చేస్తాయి మరియు లోపాల ప్రమాదాన్ని తగ్గిస్తాయి.

• నోడ్.జెఎస్ స్ట్రీమ్స్ API: నోడ్.జెఎస్ స్ట్రీమ్స్ API స్ట్రీమింగ్ డేటాను నిర్వహించడానికి ఒక బలమైన మరియు సమర్థవంతమైన మార్గాన్ని అందిస్తుంది. ఇందులో బ్యాక్‌ప్రెషర్‌ను నిర్వహించడానికి మరియు సరైన క్లీనప్‌ను నిర్ధారించడానికి యంత్రాంగాలు ఉంటాయి.
• RxJS (జావాస్క్రిప్ట్ కోసం రియాక్టివ్ ఎక్స్‌టెన్షన్స్): RxJS అనేది రియాక్టివ్ ప్రోగ్రామింగ్ కోసం ఒక లైబ్రరీ, ఇది అసమకాలిక డేటా స్ట్రీమ్‌లను నిర్వహించడానికి శక్తివంతమైన సాధనాలను అందిస్తుంది. ఇందులో లోపాలను నిర్వహించడం, ఆపరేషన్‌లను మళ్లీ ప్రయత్నించడం మరియు వనరుల క్లీనప్‌ను నిర్ధారించడం కోసం ఆపరేటర్లు ఉంటాయి.
• ఆటో-క్లీనప్‌తో లైబ్రరీలు: కొన్ని డేటాబేస్ మరియు నెట్‌వర్కింగ్ లైబ్రరీలు ఆటోమేటిక్ కనెక్షన్ పూలింగ్ మరియు వనరుల విడుదలతో రూపొందించబడ్డాయి.

ఉదాహరణ (నోడ్.జెఎస్ స్ట్రీమ్స్ 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('Pipeline succeeded.');
  } catch (err) {
    console.error('Pipeline failed.', 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 error! Status: ${response.status}`);
    }

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

    while (true) {
      if (cancellationToken.isCancelled) {
        console.log('Fetch cancelled.');
        reader.cancel(); // స్ట్రీమ్‌ను రద్దు చేయండి
        return;
      }

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

      yield decoder.decode(value);
    }
  } catch (error) {
    console.error('Error fetching data:', 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 processing data:', error);
  }
}

main();

ఈ ఉదాహరణలో, fetchData జెనరేటర్ ఒక రద్దు టోకెన్‌ను అంగీకరిస్తుంది. టోకెన్ రద్దు చేయబడితే, జెనరేటర్ ఫెచ్ అభ్యర్థనను రద్దు చేస్తుంది మరియు ఏవైనా సంబంధిత వనరులను విడుదల చేస్తుంది.

2. WeakRef మరియు FinalizationRegistry

WeakRef మరియు FinalizationRegistry అనేవి అధునాతన ఫీచర్లు, ఇవి ఆబ్జెక్ట్ జీవితచక్రాన్ని ట్రాక్ చేయడానికి మరియు ఒక ఆబ్జెక్ట్ గార్బేజ్ కలెక్ట్ చేయబడినప్పుడు క్లీనప్ చేయడానికి మిమ్మల్ని అనుమతిస్తాయి. ఇవి ఇతర ఆబ్జెక్ట్‌ల జీవితచక్రానికి ముడిపడి ఉన్న వనరులను నిర్వహించడానికి ఉపయోగపడతాయి.

గమనిక: ఈ టెక్నిక్‌లను జాగ్రత్తగా వాడండి, ఎందుకంటే అవి గార్బేజ్ కలెక్షన్ ప్రవర్తనపై ఆధారపడి ఉంటాయి, ఇది ఎల్లప్పుడూ ఊహించదగినది కాదు.

ఉదాహరణ:

const registry = new FinalizationRegistry(heldValue => {
  console.log(`Cleanup: ${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('Processing error!');
        }
        yield `Processed: ${data}`;
      } catch (error) {
        console.error('Error processing data:', error);
        // సమస్యాత్మక డేటాను తిరిగి పొందండి లేదా దాటవేయండి
        yield `Error: ${error.message}`;
      }
    }
  } catch (error) {
    console.error('Stream 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(`Processing: ${line}`);
    }
  } finally {
    fileStream.close(); // ఫైల్ స్ట్రీమ్ మూసివేయబడిందని నిర్ధారించుకోండి
    console.log('File stream closed.');
  }
}

async function main() {
  try{
    await processLargeCSV('large_data.csv');
  } catch (error) {
    console.error('Error processing 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('Database connection released.');
    }
  }
}

async function main() {
  try{
    const data = await fetchDataFromDatabase('SELECT * FROM mytable');
    console.log('Data:', data);
  } catch (error) {
    console.error('Error fetching data:', 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('Connection closed.');
    });
  });
}

async function main() {
  try {
    const data = await fetchDataFromAPI('https://jsonplaceholder.typicode.com/todos/1');
    console.log('Data:', data);
  } catch (error) {
    console.error('Error fetching data:', error);
  }
}

main();

ముగింపు

బలమైన మరియు స్కేలబుల్ జావాస్క్రిప్ట్ అప్లికేషన్‌లను నిర్మించడానికి సమర్థవంతమైన రిసోర్స్ మేనేజ్‌మెంట్ మరియు ఆటోమేటెడ్ స్ట్రీమ్ క్లీనప్ చాలా ముఖ్యమైనవి. అసింక్ ఇటరేటర్లు మరియు జెనరేటర్లను అర్థం చేసుకోవడం ద్వారా, మరియు try...finally బ్లాక్‌లు, Symbol.asyncDispose (అందుబాటులో ఉన్నప్పుడు), రిసోర్స్ వ్రాపర్లు, రద్దు టోకెన్‌లు మరియు ఎర్రర్ బౌండరీలు వంటి టెక్నిక్‌లను ఉపయోగించడం ద్వారా, డెవలపర్లు లోపాలు లేదా రద్దుల సమక్షంలో కూడా వనరులు ఎల్లప్పుడూ విడుదల చేయబడతాయని నిర్ధారించుకోవచ్చు.

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

మరింత నేర్చుకోవడానికి

• అసింక్ ఇటరేటర్లు మరియు జెనరేటర్లపై MDN వెబ్ డాక్స్: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for-await...of
• నోడ్.జెఎస్ స్ట్రీమ్స్ API డాక్యుమెంటేషన్: https://nodejs.org/api/stream.html
• RxJS డాక్యుమెంటేషన్: https://rxjs.dev/
• ఎక్స్‌ప్లిసిట్ రిసోర్స్ మేనేజ్‌మెంట్ ప్రపోజల్: https://github.com/tc39/proposal-explicit-resource-management

ఇక్కడ సమర్పించిన ఉదాహరణలు మరియు టెక్నిక్‌లను మీ నిర్దిష్ట వినియోగ కేసులకు మరియు వాతావరణాలకు అనుగుణంగా మార్చాలని గుర్తుంచుకోండి మరియు మీ అప్లికేషన్‌ల దీర్ఘకాలిక ఆరోగ్యం మరియు స్థిరత్వాన్ని నిర్ధారించడానికి ఎల్లప్పుడూ రిసోర్స్ మేనేజ్‌మెంట్‌కు ప్రాధాన్యత ఇవ్వండి.