ترکیب توابع جنریتور جاوا اسکریپت: ساخت زنجیره‌های جنریتور

توابع جنریتور جاوا اسکریپت روشی قدرتمند برای ایجاد دنباله‌های قابل پیمایش (iterable) فراهم می‌کنند. آن‌ها اجرا را متوقف کرده و مقادیری را بازمی‌گردانند (yield)، که امکان پردازش داده کارآمد و انعطاف‌پذیر را فراهم می‌کند. یکی از جالب‌ترین قابلیت‌های جنریتورها، توانایی آن‌ها در ترکیب با یکدیگر و ایجاد پایپ‌لاین‌های داده پیچیده است. این پست به مفهوم ترکیب توابع جنریتور می‌پردازد و تکنیک‌های مختلف ساخت زنجیره‌های جنریتور برای حل مسائل پیچیده را بررسی می‌کند.

توابع جنریتور جاوا اسکریپت چه هستند؟

قبل از پرداختن به ترکیب، بیایید به طور خلاصه توابع جنریتور را مرور کنیم. یک تابع جنریتور با استفاده از سینتکس function* تعریف می‌شود. در داخل یک تابع جنریتور، از کلمه کلیدی yield برای متوقف کردن اجرا و بازگرداندن یک مقدار استفاده می‌شود. هنگامی که متد next() جنریتور فراخوانی می‌شود، اجرا از جایی که متوقف شده بود تا دستور yield بعدی یا پایان تابع از سر گرفته می‌شود.

در اینجا یک مثال ساده آورده شده است:

            
function* numberGenerator(max) {
  for (let i = 0; i <= max; i++) {
    yield i;
  }
}

const generator = numberGenerator(5);

console.log(generator.next()); // Output: { value: 0, done: false }
console.log(generator.next()); // Output: { value: 1, done: false }
console.log(generator.next()); // Output: { value: 2, done: false }
console.log(generator.next()); // Output: { value: 3, done: false }
console.log(generator.next()); // Output: { value: 4, done: false }
console.log(generator.next()); // Output: { value: 5, done: false }
console.log(generator.next()); // Output: { value: undefined, done: true }

            

              
                Copy
              
            
          

این تابع جنریتور اعدادی را از 0 تا یک مقدار حداکثر مشخص شده بازمی‌گرداند. متد next() یک شیء با دو ویژگی بازمی‌گرداند: value (مقدار بازگردانده شده) و done (یک مقدار بولین که نشان می‌دهد آیا جنریتور به پایان رسیده است یا خیر).

چرا توابع جنریتور را ترکیب کنیم؟

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

این مزایای ترکیب را در نظر بگیرید:

• ماژولار بودن: هر جنریتور یک مسئولیت واحد دارد، که درک و نگهداری کد را آسان‌تر می‌کند.
• قابلیت استفاده مجدد: جنریتورها می‌توانند در پایپ‌لاین‌های مختلف مجدداً استفاده شوند و از تکرار کد جلوگیری کنند.
• قابلیت تست: جنریتورهای کوچکتر به راحتی به صورت مجزا قابل تست هستند.
• انعطاف‌پذیری: پایپ‌لاین‌ها را می‌توان با افزودن، حذف یا تغییر ترتیب جنریتورها به راحتی اصلاح کرد.

تکنیک‌های ترکیب توابع جنریتور

چندین تکنیک برای ترکیب توابع جنریتور در جاوا اسکریپت وجود دارد. بیایید برخی از رایج‌ترین رویکردها را بررسی کنیم.

۱. تفویض جنریتور (yield*)

کلمه کلیدی yield* روشی مناسب برای تفویض اختیار به یک شیء قابل پیمایش دیگر، از جمله یک تابع جنریتور دیگر، فراهم می‌کند. هنگامی که از yield* استفاده می‌شود، مقادیری که توسط iterable تفویض شده بازگردانده می‌شوند، مستقیماً توسط جنریتور فعلی بازگردانده می‌شوند.

در اینجا مثالی از استفاده از yield* برای ترکیب دو تابع جنریتور آورده شده است:

            
function* generateEvenNumbers(max) {
  for (let i = 0; i <= max; i++) {
    if (i % 2 === 0) {
      yield i;
    }
  }
}

function* prependMessage(message, iterable) {
  yield message;
  yield* iterable;
}

const evenNumbers = generateEvenNumbers(10);
const messageGenerator = prependMessage("Even Numbers:", evenNumbers);

for (const value of messageGenerator) {
  console.log(value);
}

// Output:
// Even Numbers:
// 0
// 2
// 4
// 6
// 8
// 10

            

              
                Copy
              
            
          

در این مثال، prependMessage یک پیام را بازمی‌گرداند و سپس با استفاده از yield* به جنریتور generateEvenNumbers تفویض می‌کند. این کار به طور موثر دو جنریتور را در یک دنباله واحد ترکیب می‌کند.

۲. پیمایش دستی و Yield کردن

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

            
function* generateOddNumbers(max) {
  for (let i = 0; i <= max; i++) {
    if (i % 2 !== 0) {
      yield i;
    }
  }
}

function* appendMessage(iterable, message) {
  for (const value of iterable) {
    yield value;
  }
  yield message;
}

const oddNumbers = generateOddNumbers(9);
const messageGenerator = appendMessage(oddNumbers, "End of Sequence");

for (const value of messageGenerator) {
  console.log(value);
}

// Output:
// 1
// 3
// 5
// 7
// 9
// End of Sequence

            

              
                Copy
              
            
          

در این مثال، appendMessage با استفاده از یک حلقه for...of روی جنریتور oddNumbers پیمایش کرده و هر مقدار را بازمی‌گرداند. پس از پیمایش کل جنریتور، پیام نهایی را بازمی‌گرداند.

۳. ترکیب تابعی با توابع رده-بالا

می‌توانید از توابع رده-بالا (higher-order functions) برای ایجاد یک سبک ترکیب جنریتور تابعی و اعلانی‌تر استفاده کنید. این شامل ایجاد توابعی است که جنریتورها را به عنوان ورودی می‌گیرند و جنریتورهای جدیدی را بازمی‌گردانند که تبدیل‌هایی را روی جریان داده انجام می‌دهند.

            
function* numberRange(start, end) {
  for (let i = start; i <= end; i++) {
    yield i;
  }
}

function mapGenerator(generator, transform) {
  return function*() {
    for (const value of generator) {
      yield transform(value);
    }
  };
}

function filterGenerator(generator, predicate) {
  return function*() {
    for (const value of generator) {
      if (predicate(value)) {
        yield value;
      }
    }
  };
}

const numbers = numberRange(1, 10);
const squaredNumbers = mapGenerator(numbers, x => x * x)();
const evenSquaredNumbers = filterGenerator(squaredNumbers, x => x % 2 === 0)();

for (const value of evenSquaredNumbers) {
  console.log(value);
}

// Output:
// 4
// 16
// 36
// 64
// 100

            

              
                Copy
              
            
          

در این مثال، mapGenerator و filterGenerator توابع رده-بالا هستند که یک جنریتور و یک تابع تبدیل یا شرطی (predicate) را به عنوان ورودی می‌گیرند. آن‌ها توابع جنریتور جدیدی را بازمی‌گردانند که تبدیل یا فیلتر را بر روی مقادیر بازگردانده شده توسط جنریتور اصلی اعمال می‌کنند. این به شما امکان می‌دهد تا با زنجیر کردن این توابع رده-بالا، پایپ‌لاین‌های پیچیده‌ای بسازید.

۴. کتابخانه‌های پایپ‌لاین جنریتور (مانند IxJS)

چندین کتابخانه جاوا اسکریپت ابزارهایی برای کار با iterables و جنریتورها به روشی تابعی و اعلانی‌تر ارائه می‌دهند. یک مثال IxJS (Interactive Extensions for JavaScript) است که مجموعه غنی از عملگرها را برای تبدیل و ترکیب iterables فراهم می‌کند.

توجه: استفاده از کتابخانه‌های خارجی به پروژه شما وابستگی اضافه می‌کند. مزایا را در مقابل هزینه‌ها ارزیابی کنید.

            
// Example using IxJS (install: npm install ix)
const { from, map, filter } = require('ix/iterable');

function* numberRange(start, end) {
  for (let i = start; i <= end; i++) {
    yield i;
  }
}

const numbers = from(numberRange(1, 10));
const squaredNumbers = map(numbers, x => x * x);
const evenSquaredNumbers = filter(squaredNumbers, x => x % 2 === 0);

for (const value of evenSquaredNumbers) {
  console.log(value);
}

// Output:
// 4
// 16
// 36
// 64
// 100

            

              
                Copy
              
            
          

این مثال از IxJS برای انجام همان تبدیل‌های مثال قبلی استفاده می‌کند، اما به روشی مختصرتر و اعلانی‌تر. IxJS عملگرهایی مانند map و filter را فراهم می‌کند که روی iterables عمل می‌کنند و ساخت پایپ‌لاین‌های پردازش داده پیچیده را آسان‌تر می‌کنند.

مثال‌های دنیای واقعی از ترکیب توابع جنریتور

ترکیب توابع جنریتور می‌تواند در سناریوهای مختلف دنیای واقعی به کار رود. در اینجا چند مثال آورده شده است:

۱. پایپ‌لاین‌های تبدیل داده

تصور کنید در حال پردازش داده از یک فایل CSV هستید. می‌توانید یک پایپ‌لاین از جنریتورها برای انجام تبدیل‌های مختلف ایجاد کنید، مانند:

• خواندن فایل CSV و بازگرداندن هر ردیف به عنوان یک شیء.
• فیلتر کردن ردیف‌ها بر اساس معیارهای خاص (مثلاً فقط ردیف‌هایی با کد کشور مشخص).
• تبدیل داده در هر ردیف (مثلاً تبدیل تاریخ‌ها به فرمت خاص، انجام محاسبات).
• نوشتن داده‌های تبدیل شده به یک فایل یا پایگاه داده جدید.

هر یک از این مراحل می‌تواند به عنوان یک تابع جنریتور جداگانه پیاده‌سازی شود و سپس برای تشکیل یک پایپ‌لاین کامل پردازش داده با هم ترکیب شوند. به عنوان مثال، اگر منبع داده یک CSV از مکان‌های مشتریان در سراسر جهان باشد، می‌توانید مراحلی مانند فیلتر کردن بر اساس کشور (مثلاً «ژاپن»، «برزیل»، «آلمان») و سپس اعمال تبدیلی که فواصل تا یک دفتر مرکزی را محاسبه می‌کند، داشته باشید.

۲. جریان‌های داده ناهمزمان

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

واکشی پروفایل‌های کاربران از یک API صفحه‌بندی شده را در نظر بگیرید. یک جنریتور می‌تواند هر صفحه را واکشی کرده و پروفایل‌های کاربران آن صفحه را با yield* بازگرداند. جنریتور دیگری می‌تواند این پروفایل‌ها را بر اساس فعالیت در ماه گذشته فیلتر کند.

۳. پیاده‌سازی ایتریتورهای سفارشی

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

به عنوان مثال، می‌توانید یک جنریتور ایجاد کنید که یک درخت دودویی را به ترتیب خاصی (مثلاً in-order، pre-order، post-order) پیمایش کند یا سلول‌های یک صفحه گسترده را ردیف به ردیف پیمایش کند.

بهترین شیوه‌ها برای ترکیب توابع جنریتور

در اینجا برخی از بهترین شیوه‌ها برای به خاطر سپردن هنگام ترکیب توابع جنریتور آورده شده است:

• جنریتورها را کوچک و متمرکز نگه دارید: هر جنریتور باید یک مسئولیت واحد و به خوبی تعریف شده داشته باشد. این کار درک، تست و نگهداری کد را آسان‌تر می‌کند.
• از نام‌های توصیفی استفاده کنید: به جنریتورهای خود نام‌های توصیفی بدهید که به وضوح هدف آنها را نشان دهد.
• خطاها را به درستی مدیریت کنید: مدیریت خطا را در هر جنریتور پیاده‌سازی کنید تا از انتشار خطاها در سراسر پایپ‌لاین جلوگیری شود. استفاده از بلوک‌های try...catch را در جنریتورهای خود در نظر بگیرید.
• عملکرد را در نظر بگیرید: در حالی که جنریتورها به طور کلی کارآمد هستند، پایپ‌لاین‌های پیچیده هنوز هم می‌توانند بر عملکرد تأثیر بگذارند. کد خود را پروفایل کرده و در صورت لزوم بهینه‌سازی کنید.
• کد خود را مستند کنید: هدف هر جنریتور و نحوه تعامل آن با سایر جنریتورها در پایپ‌لاین را به وضوح مستند کنید.

تکنیک‌های پیشرفته

مدیریت خطا در زنجیره‌های جنریتور

مدیریت خطاها در زنجیره‌های جنریتور نیاز به توجه دقیق دارد. هنگامی که خطایی در یک جنریتور رخ می‌دهد، می‌تواند کل پایپ‌لاین را مختل کند. چند استراتژی وجود دارد که می‌توانید به کار بگیرید:

1. Try-Catch در داخل جنریتورها: ساده‌ترین رویکرد، قرار دادن کد درون هر تابع جنریتور در یک بلوک try...catch است. این به شما امکان می‌دهد خطاها را به صورت محلی مدیریت کنید و به طور بالقوه یک مقدار پیش‌فرض یا یک شیء خطای خاص را بازگردانید.
2. مرزهای خطا (مفهومی از React، قابل انطباق در اینجا): یک جنریتور پوششی ایجاد کنید که هر استثنایی را که توسط جنریتور تفویض شده‌اش پرتاب می‌شود، بگیرد. این به شما امکان می‌دهد خطا را ثبت کرده و به طور بالقوه زنجیره را با یک مقدار جایگزین از سر بگیرید.

            
function* potentiallyFailingGenerator() {
  try {
    // Code that might throw an error
    const result = someRiskyOperation();
    yield result;
  } catch (error) {
    console.error("Error in potentiallyFailingGenerator:", error);
    yield null; // Or yield a specific error object
  }
}

function* errorBoundary(generator) {
    try {
        yield* generator();
    } catch (error) {
        console.error("Error Boundary Caught:", error);
        yield "Fallback Value"; // Or some other recovery mechanism
    }
}

const myGenerator = errorBoundary(potentiallyFailingGenerator);

for (const value of myGenerator) {
  console.log(value);
}

            

              
                Copy
              
            
          

جنریتورهای ناهمزمان و ترکیب آن‌ها

با معرفی جنریتورهای ناهمزمان در جاوا اسکریپت، اکنون می‌توانید زنجیره‌های جنریتوری بسازید که داده‌های ناهمزمان را به طور طبیعی‌تری پردازش می‌کنند. جنریتورهای ناهمزمان از سینتکس async function* استفاده می‌کنند و می‌توانند از کلمه کلیدی await برای منتظر ماندن برای عملیات ناهمزمان استفاده کنند.

            
async function* fetchUsers(userIds) {
  for (const userId of userIds) {
    const user = await fetchUser(userId); // Assuming fetchUser is an async function
    yield user;
  }
}

async function* filterActiveUsers(users) {
  for await (const user of users) {
    if (user.isActive) {
      yield user;
    }
  }
}

async function fetchUser(id) {
    //Simulate an async fetch
    return new Promise(resolve => {
        setTimeout(() => {
            resolve({ id: id, name: `User ${id}`, isActive: id % 2 === 0});
        }, 500);
    });
}

async function main() {
  const userIds = [1, 2, 3, 4, 5];
  const users = fetchUsers(userIds);
  const activeUsers = filterActiveUsers(users);

  for await (const user of activeUsers) {
    console.log(user);
  }
}

main();

//Possible output:
// { id: 2, name: 'User 2', isActive: true }
// { id: 4, name: 'User 4', isActive: true }

            

              
                Copy
              
            
          

برای پیمایش روی جنریتورهای ناهمزمان، باید از حلقه for await...of استفاده کنید. جنریتورهای ناهمزمان را می‌توان با استفاده از yield* به همان روش جنریتورهای معمولی ترکیب کرد.

نتیجه‌گیری

ترکیب توابع جنریتور یک تکنیک قدرتمند برای ساخت پایپ‌لاین‌های پردازش داده ماژولار، قابل استفاده مجدد و قابل تست در جاوا اسکریپت است. با تقسیم مسائل پیچیده به جنریتورهای کوچکتر و قابل مدیریت، می‌توانید کدی قابل نگهداری و انعطاف‌پذیرتر ایجاد کنید. چه در حال تبدیل داده از یک فایل CSV، پردازش جریان‌های داده ناهمزمان یا پیاده‌سازی ایتریتورهای سفارشی باشید، ترکیب توابع جنریتور می‌تواند به شما در نوشتن کدی تمیزتر و کارآمدتر کمک کند. با درک تکنیک‌های مختلف ترکیب توابع جنریتور، از جمله تفویض جنریتور، پیمایش دستی و ترکیب تابعی با توابع رده-بالا، می‌توانید از پتانسیل کامل جنریتورها در پروژه‌های جاوا اسکریپت خود بهره‌برداری کنید. به یاد داشته باشید که بهترین شیوه‌ها را دنبال کنید، خطاها را به درستی مدیریت کنید و هنگام طراحی پایپ‌لاین‌های جنریتور خود، عملکرد را در نظر بگیرید. با رویکردهای مختلف آزمایش کنید و تکنیک‌هایی را پیدا کنید که به بهترین وجه با نیازها و سبک کدنویسی شما مطابقت دارد. در نهایت، کتابخانه‌های موجود مانند IxJS را برای بهبود بیشتر گردش کار مبتنی بر جنریتور خود کاوش کنید. با تمرین، قادر خواهید بود با استفاده از توابع جنریتور جاوا اسکریپت، راه‌حل‌های پردازش داده پیچیده و کارآمد بسازید.