۲۲ شهریور ۱۴۰۴فارسی

بر Async Iterator های جاوا اسکریپت برای مدیریت بهینه منابع و اتوماسیون پاک‌سازی استریم مسلط شوید. بهترین شیوه‌ها، تکنیک‌های پیشرفته و مثال‌های واقعی برای برنامه‌های قوی و مقیاس‌پذیر را بیاموزید.

مدیریت منابع در Async Iterator جاوا اسکریپت: اتوماسیون پاک‌سازی استریم

تکرارکننده‌ها (iterators) و مولدهای (generators) ناهمزمان، ویژگی‌های قدرتمندی در جاوا اسکریپت هستند که امکان مدیریت کارآمد استریم‌های داده و عملیات ناهمزمان را فراهم می‌کنند. با این حال، مدیریت منابع و اطمینان از پاک‌سازی صحیح در محیط‌های ناهمزمان می‌تواند چالش‌برانگیز باشد. بدون توجه دقیق، این موارد می‌توانند منجر به نشت حافظه، اتصالات بسته نشده و سایر مشکلات مرتبط با منابع شوند. این مقاله به بررسی تکنیک‌هایی برای اتوماسیون پاک‌سازی استریم در تکرارکننده‌های ناهمزمان جاوا اسکریپت می‌پردازد و بهترین شیوه‌ها و مثال‌های عملی را برای اطمینان از برنامه‌های قوی و مقیاس‌پذیر ارائه می‌دهد.

درک تکرارکننده‌ها و مولدهای ناهمزمان

قبل از پرداختن به مدیریت منابع، بیایید اصول اولیه تکرارکننده‌ها و مولدهای ناهمزمان را مرور کنیم.

تکرارکننده‌های ناهمزمان (Async Iterators)

یک تکرارکننده ناهمزمان (async iterator) شیئی است که متد next() را تعریف می‌کند. این متد یک promise برمی‌گرداند که به شیئی با دو خصوصیت resolve می‌شود:

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(); // Output: 1, 2, 3

مولدهای ناهمزمان (Async Generators)

مولدهای ناهمزمان توابعی هستند که تکرارکننده‌های ناهمزمان را برمی‌گردانند. آنها از سینتکس async function* و کلمه کلیدی yield برای تولید مقادیر به صورت ناهمزمان استفاده می‌کنند.

مثال:


async function* generateSequence(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 500)); // Simulate asynchronous operation
    yield i;
  }
}

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

main(); // Output: 1, 2, 3, 4, 5 (with 500ms delay between each value)

چالش: مدیریت منابع در استریم‌های ناهمزمان

هنگام کار با استریم‌های ناهمزمان، مدیریت مؤثر منابع بسیار حیاتی است. منابع ممکن است شامل دستگیره‌های فایل (file handles)، اتصالات پایگاه داده، سوکت‌های شبکه یا هر منبع خارجی دیگری باشند که باید در طول چرخه حیات استریم به دست آمده و آزاد شوند. عدم مدیریت صحیح این منابع می‌تواند منجر به موارد زیر شود:

نشت حافظه (Memory Leaks): منابع زمانی که دیگر مورد نیاز نیستند آزاد نمی‌شوند و با گذشت زمان حافظه بیشتری مصرف می‌کنند.
اتصالات بسته نشده (Unclosed Connections): اتصالات پایگاه داده یا شبکه باز باقی می‌مانند، محدودیت‌های اتصال را به اتمام می‌رسانند و به طور بالقوه باعث مشکلات عملکردی یا خطا می‌شوند.
پایان یافتن دستگیره‌های فایل (File Handle Exhaustion): دستگیره‌های فایل باز انباشته می‌شوند و زمانی که برنامه تلاش می‌کند فایل‌های بیشتری باز کند، منجر به خطا می‌شود.
رفتار غیرقابل پیش‌بینی (Unpredictable Behavior): مدیریت نادرست منابع می‌تواند منجر به خطاهای غیرمنتظره و ناپایداری برنامه شود.

پیچیدگی کدهای ناهمزمان، به ویژه در مدیریت خطا، می‌تواند مدیریت منابع را چالش‌برانگیز کند. ضروری است اطمینان حاصل شود که منابع همیشه آزاد می‌شوند، حتی زمانی که خطاها در حین پردازش استریم رخ می‌دهند.

اتوماسیون پاک‌سازی استریم: تکنیک‌ها و بهترین شیوه‌ها

برای مقابله با چالش‌های مدیریت منابع در تکرارکننده‌های ناهمزمان، می‌توان از چندین تکنیک برای اتوماسیون پاک‌سازی استریم استفاده کرد.

۱. بلوک `try...finally`

بلوک try...finally یک مکانیزم اساسی برای اطمینان از پاک‌سازی منابع است. بلوک finally همیشه اجرا می‌شود، صرف نظر از اینکه آیا در بلوک try خطایی رخ داده است یا خیر.

مثال:


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 تضمین می‌کند که دستگیره فایل همیشه بسته می‌شود، حتی اگر در هنگام خواندن فایل خطایی رخ دهد.

۲. استفاده از `Symbol.asyncDispose` (پروپوزال مدیریت صریح منابع)

پروپوزال مدیریت صریح منابع (Explicit Resource Management) نماد Symbol.asyncDispose را معرفی می‌کند که به اشیاء اجازه می‌دهد متدی را تعریف کنند که به طور خودکار زمانی که شیء دیگر مورد نیاز نیست، فراخوانی می‌شود. این شبیه به دستور using در C# یا دستور 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)); // Simulate async cleanup
    console.log('Resource released.');
  }
}

async function main() {
  await using(new MyResource(), async (resource) => {
    console.log('Using resource...');
    // ... use the resource
  }); // Resource is automatically disposed here
  console.log('After using block.');
}

main();

در این مثال، دستور using تضمین می‌کند که متد [Symbol.asyncDispose] شیء MyResource هنگام خروج از بلوک فراخوانی می‌شود، صرف نظر از اینکه خطایی رخ داده باشد یا خیر. این روشی قطعی و قابل اعتماد برای آزاد کردن منابع فراهم می‌کند.

۳. پیاده‌سازی یک بسته‌بند منبع (Resource Wrapper)

رویکرد دیگر ایجاد یک کلاس بسته‌بند منبع است که منبع و منطق پاک‌سازی آن را کپسوله می‌کند. این کلاس می‌تواند متدهایی برای به دست آوردن و آزاد کردن منبع پیاده‌سازی کند و اطمینان حاصل کند که پاک‌سازی همیشه به درستی انجام می‌شود.

مثال:


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 از این کلاس استفاده می‌کند تا اطمینان حاصل کند که دستگیره فایل همیشه آزاد می‌شود، حتی اگر خطایی رخ دهد.

۴. بهره‌گیری از کتابخانه‌ها و فریمورک‌ها

بسیاری از کتابخانه‌ها و فریمورک‌ها مکانیزم‌های داخلی برای مدیریت منابع و پاک‌سازی استریم ارائه می‌دهند. این‌ها می‌توانند فرآیند را ساده کرده و خطر خطا را کاهش دهند.

API استریم‌های Node.js: API استریم‌های Node.js روشی قوی و کارآمد برای مدیریت داده‌های جریانی فراهم می‌کند. این API شامل مکانیزم‌هایی برای مدیریت فشار برگشتی (backpressure) و اطمینان از پاک‌سازی مناسب است.
RxJS (Reactive Extensions for JavaScript): RxJS کتابخانه‌ای برای برنامه‌نویسی واکنشی است که ابزارهای قدرتمندی برای مدیریت استریم‌های داده ناهمزمان فراهم می‌کند. این کتابخانه شامل اپراتورهایی برای مدیریت خطاها، تلاش مجدد عملیات و اطمینان از پاک‌سازی منابع است.
کتابخانه‌های با پاک‌سازی خودکار: برخی از کتابخانه‌های پایگاه داده و شبکه با قابلیت تجمیع اتصالات (connection pooling) و آزادسازی خودکار منابع طراحی شده‌اند.

مثال (با استفاده از API استریم‌های Node.js):


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 به طور خودکار استریم‌ها را مدیریت می‌کند و اطمینان می‌دهد که به درستی بسته شده و هرگونه خطا به درستی مدیریت می‌شود.

تکنیک‌های پیشرفته برای مدیریت منابع

فراتر از تکنیک‌های اصلی، چندین استراتژی پیشرفته می‌تواند مدیریت منابع در تکرارکننده‌های ناهمزمان را بیشتر بهبود بخشد.

۱. توکن‌های لغو (Cancellation Tokens)

توکن‌های لغو مکانیزمی برای لغو کردن عملیات ناهمزمان فراهم می‌کنند. این می‌تواند برای آزاد کردن منابع زمانی که یک عملیات دیگر مورد نیاز نیست، مفید باشد، مانند زمانی که کاربر یک درخواست را لغو می‌کند یا یک تایم‌اوت رخ می‌دهد.

مثال:


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(); // Cancel the stream
        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'; // Replace with a valid URL

  setTimeout(() => {
    cancellationToken.cancel(); // Cancel after 3 seconds
  }, 3000);

  try {
    for await (const chunk of fetchData(url, cancellationToken)) {
      console.log(chunk);
    }
  } catch (error) {
    console.error('Error processing data:', error);
  }
}

main();

در این مثال، مولد fetchData یک توکن لغو می‌پذیرد. اگر توکن لغو شود، مولد درخواست fetch را لغو کرده و هرگونه منابع مرتبط را آزاد می‌کند.

۲. WeakRefs و FinalizationRegistry

WeakRef و FinalizationRegistry ویژگی‌های پیشرفته‌ای هستند که به شما امکان می‌دهند چرخه حیات اشیاء را ردیابی کرده و هنگامی که یک شیء توسط garbage collector جمع‌آوری می‌شود، عملیات پاک‌سازی را انجام دهید. این‌ها می‌توانند برای مدیریت منابعی که به چرخه حیات اشیاء دیگر گره خورده‌اند، مفید باشند.

نکته: از این تکنیک‌ها با احتیاط استفاده کنید زیرا به رفتار garbage collection متکی هستند که همیشه قابل پیش‌بینی نیست.

مثال:


const registry = new FinalizationRegistry(heldValue => {
  console.log(`Cleanup: ${heldValue}`);
  // Perform cleanup here (e.g., close connections)
});

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

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

// ... later, if obj1 and obj2 are no longer referenced:
// obj1 = null;
// obj2 = null;
// Garbage collection will eventually trigger the FinalizationRegistry
// and the cleanup message will be logged.

۳. مرزهای خطا و بازیابی (Error Boundaries and Recovery)

پیاده‌سازی مرزهای خطا می‌تواند به جلوگیری از انتشار خطاها و مختل شدن کل استریم کمک کند. مرزهای خطا می‌توانند خطاها را گرفته و مکانیزمی برای بازیابی یا خاتمه دادن به استریم به صورت کنترل‌شده فراهم کنند.

مثال:


async function* processData(dataStream) {
  try {
    for await (const data of dataStream) {
      try {
        // Simulate potential error during processing
        if (Math.random() < 0.1) {
          throw new Error('Processing error!');
        }
        yield `Processed: ${data}`;
      } catch (error) {
        console.error('Error processing data:', error);
        // Recover or skip the problematic data
        yield `Error: ${error.message}`;
      }
    }
  } catch (error) {
    console.error('Stream error:', error);
    // Handle the stream error (e.g., log, terminate)
  }
}

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();

مثال‌های واقعی و موارد استفاده

بیایید چند مثال واقعی و موارد استفاده را بررسی کنیم که در آنها پاک‌سازی خودکار استریم حیاتی است.

۱. استریم کردن فایل‌های بزرگ

هنگام استریم کردن فایل‌های بزرگ، اطمینان از بسته شدن صحیح دستگیره فایل پس از پردازش ضروری است. این کار از اتمام دستگیره‌های فایل جلوگیری کرده و تضمین می‌کند که فایل به طور نامحدود باز نماند.

مثال (خواندن و پردازش یک فایل 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) {
      // Process each line of the CSV file
      console.log(`Processing: ${line}`);
    }
  } finally {
    fileStream.close(); // Ensure the file stream is closed
    console.log('File stream closed.');
  }
}

async function main() {
  try{
    await processLargeCSV('large_data.csv');
  } catch (error) {
    console.error('Error processing CSV:', error);
  }
}

main();

۲. مدیریت اتصالات پایگاه داده

هنگام کار با پایگاه‌های داده، آزاد کردن اتصالات پس از اینکه دیگر مورد نیاز نیستند، بسیار مهم است. این کار از اتمام اتصالات جلوگیری کرده و تضمین می‌کند که پایگاه داده می‌تواند به درخواست‌های دیگر رسیدگی کند.

مثال (واکشی داده از پایگاه داده و بستن اتصال):


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(); // Release the connection back to the pool
      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();

۳. پردازش استریم‌های شبکه

هنگام پردازش استریم‌های شبکه، بستن سوکت یا اتصال پس از دریافت داده‌ها ضروری است. این کار از نشت منابع جلوگیری کرده و تضمین می‌کند که سرور می‌تواند به اتصالات دیگر رسیدگی کند.

مثال (واکشی داده از یک 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 استریم‌های Node.js: https://nodejs.org/api/stream.html
مستندات RxJS: https://rxjs.dev/
پروپوزال مدیریت صریح منابع: https://github.com/tc39/proposal-explicit-resource-management

به یاد داشته باشید که مثال‌ها و تکنیک‌های ارائه شده در اینجا را با موارد استفاده و محیط‌های خاص خود تطبیق دهید و همیشه مدیریت منابع را در اولویت قرار دهید تا سلامت و پایداری بلندمدت برنامه‌های خود را تضمین کنید.

مدیریت منابع در Async Iterator جاوا اسکریپت: اتوماسیون پاک‌سازی استریم

درک تکرارکننده‌ها و مولدهای ناهمزمان

تکرارکننده‌های ناهمزمان (Async Iterators)

مولدهای ناهمزمان (Async Generators)

چالش: مدیریت منابع در استریم‌های ناهمزمان

اتوماسیون پاک‌سازی استریم: تکنیک‌ها و بهترین شیوه‌ها

۱. بلوک try...finally

۲. استفاده از Symbol.asyncDispose (پروپوزال مدیریت صریح منابع)

۳. پیاده‌سازی یک بسته‌بند منبع (Resource Wrapper)

۴. بهره‌گیری از کتابخانه‌ها و فریمورک‌ها

تکنیک‌های پیشرفته برای مدیریت منابع

۱. توکن‌های لغو (Cancellation Tokens)

۲. WeakRefs و FinalizationRegistry

۳. مرزهای خطا و بازیابی (Error Boundaries and Recovery)

مثال‌های واقعی و موارد استفاده

۱. استریم کردن فایل‌های بزرگ

۲. مدیریت اتصالات پایگاه داده

۳. پردازش استریم‌های شبکه

نتیجه‌گیری

یادگیری بیشتر

۱. بلوک `try...finally`

۲. استفاده از `Symbol.asyncDispose` (پروپوزال مدیریت صریح منابع)