iterator, generator আর yield — একটি একটি করে মান

১ · for…of-এর পেছনের চুক্তি — iterable আর iterator

পর্ব ১২-এ for…of দেখেছেন: for (const item of cart) লিখলে একটি একটি করে পণ্য আসে। পর্ব ১৭-এ spread আর destructuring দেখেছেন, পর্ব ১৮-এ Map আর Set ঘুরেছেন। এই সবকিছু কাজ করে একটিমাত্র নিয়মের ওপর। এই পর্বে আমরা সেই নিয়মটি খুলে দেখব, তারপর নিজের হাতে বানাব।

প্রশ্নটি সহজ: for…of কীভাবে জানে একটি array-এর পরের মান কোনটি, একটি string-এর পরের অক্ষর কোনটি, বা একটি Map-এর পরের জোড়া কোনটি? এদের ভেতরের গঠন সম্পূর্ণ আলাদা। উত্তর হলো — for…of জানে না, জানতেও চায় না। সে শুধু জিনিসটিকে বলে, “আমাকে একজন সাহায্যকারী দাও”, তারপর সেই সাহায্যকারীকে বারবার বলে, “পরেরটা দাও”।

চুক্তিটির দুটি অংশ, আর দুটিই ES2015 (ES6) থেকে আছে:

• Iterable protocol: জিনিসটির একটি method থাকবে, যার নাম একটি বিশেষ Symbol — Symbol.iterator. এটি ডাকলে একটি iterator ফেরত আসবে।
• Iterator protocol: iterator-এর একটি next() method থাকবে, যা প্রতিবার একটি ছোট object দেবে: { value: পরের মান, done: false }, অথবা মান শেষ হলে { value: undefined, done: true }.

নামটি string না হয়ে Symbol কেন? যাতে কারও নিজের "iterator" নামের property-র সাথে সংঘর্ষ না হয় — পুরোনো কোড ভাঙে না। Symbol-এর পুরো গল্প পর্ব ২৮-এ। এখন একটি array-এর iterator হাতে নিয়ে নিজেই next() ডেকে দেখুন। “পরে” চাপুন।

1const letters = ['ক', 'খ'];2const it = letters[Symbol.iterator]();3it.next();4it.next();5it.next();6it.next();

এই আলাদা করাটাই নকশার সৌন্দর্য। একই array-এর ওপর দুটি লুপ একসাথে চালালে (একটির ভেতরে আরেকটি) প্রতিটি লুপ নিজের iterator পায়, তাই কেউ কারও জায়গা গুলিয়ে ফেলে না। আর যে জিনিস মান দেয়, তাকে জানতে হয় না কে মান নিচ্ছে — লুপ, spread, নাকি অন্য কিছু।

২ · কে iterable আর কে নয় — আর কারা iterable খায়

JavaScript-এর অনেক built-in জিনিস নিজে থেকেই iterable. প্রতিটি কী দেয়, তা জানা থাকলে অনেক বাগ এড়ানো যায়:

সাধারণ object কেন iterable নয়? কারণ “object-এর পরের মান” কথাটির কোনো একক অর্থ নেই — key দেব, value দেব, নাকি জোড়া? ভাষা তাই অনুমান না করে আপনাকেই বেছে নিতে বলে: Object.keys(o), Object.values(o) বা Object.entries(o) — তিনটিই array দেয়, আর array iterable.

যারা iterable “খায়”

চুক্তির অন্য দিকে আছে যারা iterable নেয়। এই তালিকা দেখলে বুঝবেন একবার চুক্তি মানলে কত কিছু বিনা খরচে পাওয়া যায়:

• for (const x of it) — লুপ
• [...it] আর fn(...it) — spread
• const [a, b] = it — array destructuring (প্রয়োজনের বেশি মান চায় না)
• Array.from(it, mapFn), new Map(it), new Set(it), Object.fromEntries(it)
• Promise.all(it) আর এর ভাইবোনেরা (পর্ব ৩৩), আর generator-এর yield* (অংশ ৫)

৩ · নিজের iterable বানানো — একটি Range class

Python-এ range(1, 10, 2) আছে, JavaScript-এ নেই। চলুন বানাই — আর সেই সুযোগে চুক্তিটি নিজের হাতে মানি। পর্ব ২৬-এ class দেখেছেন; এখানে একটি class-এ শুধু একটি বাড়তি method লাগবে, যার নাম [Symbol.iterator] (বর্গ বন্ধনী মানে নামটি একটি হিসাব করা মান — এখানে Symbol). এই method প্রতিবার ডাকা হলে একটি নতুন iterator object বানিয়ে দেবে, যার নিজস্ব cur কাউন্টার closure-এ (পর্ব ২২) বন্দি থাকবে।

const it = ["ক", "খ"][Symbol.iterator]();
console.log(it.next(), it.next(), it.next());

class Range {
  constructor(start, end, step = 1) { Object.assign(this, { start, end, step }); }
  [Symbol.iterator]() {
    let cur = this.start;
    const { end, step } = this;
    return {
      next() {
        if (cur > end) return { value: undefined, done: true };
        cur += step;
        return { value: cur - step, done: false };
      },
    };
  }
}
const odd = new Range(1, 10, 2);
console.log([...odd], Math.max(...odd));
const [first, second] = odd;
console.log(first, second, Array.from(odd, (n) => n * 10));
console.log([..."👍বা"].length, "👍বা".length);

const order = { id: 7, total: 450 };
try { for (const x of order) console.log(x); }
catch (e) { console.log(`${e.name}: ${e.message}`); }

এভাবে হাতে iterator লেখা কাজ করে, কিন্তু খেয়াল করুন কত কিছু সামলাতে হলো: কাউন্টার, শেষ হলো কি না, ঠিক আকারের object ফেরত দেওয়া। আরেকটি বাস্তব উদাহরণ ভাবুন — একটি গানের Playlist class, যা ভেতরে একটি private array (#songs) রাখে। বাইরের কোডকে array-টি দিতে চান না (কেউ বদলে ফেলবে), কিন্তু চান for (const song of playlist) কাজ করুক। সমাধান: [Symbol.iterator]() { return this.#songs.values(); } — array-এর নিজের iterator দিয়ে দেওয়া, array নয়। ছোট, নিরাপদ, আর সাধারণ।

৪ · generator — থেমে থেমে চলা function

সাধারণ function একবার ডাকলে শুরু থেকে শেষ পর্যন্ত একটানা চলে, একটি মান ফেরত দেয়, আর তার সব local variable হারিয়ে যায়। পর্ব ০৫-এ দেখেছেন কেন: function-এর stack frame call stack-এ থাকে, আর function শেষ হলেই frame সরে যায়।

এখন কল্পনা করুন এমন একটি function, যে মাঝপথে থেমে একটি মান দিতে পারে, তারপর কেউ চাইলে ঠিক সেখান থেকে আবার চলতে পারে — সব local variable আগের মতো রেখে। এটাই generator. লেখার নিয়ম: function-এর পরে একটি তারকা — function* — আর ভেতরে যেখানে থামতে চান সেখানে yield.

তিনটি জিনিস প্রথমবার দেখলে অবাক লাগে। এক, generator function ডাকলে body-র একটি লাইনও চলে না — শুধু একটি generator object ফেরত আসে। দুই, এই object একই সাথে iterator (এর next() আছে) আর iterable (এর [Symbol.iterator]() নিজেকেই ফেরত দেয়)। তিন, body চলে শুধু next() ডাকলে, আর পরের yield-এ পৌঁছে থেমে যায়। কোন next()-এ কোন লাইন চলে, ধাপে ধাপে দেখুন:

1function* steps() {2  console.log('শুরু');3  yield 1;4  console.log('মাঝখান');5  yield 2;6  console.log('শেষ');7  return 'ok';8}9const g = steps();10g.next();  // চারবার ডাকা হবে

ভেতরে কী ঘটে? সাধারণ function-এর frame call stack-এ থাকে, তাই function থামলে frame হারায়। Generator-এর frame থাকে heap-এ, generator object-এর সাথে বাঁধা। next() ডাকলে engine সেই frame সাময়িকভাবে stack-এ তুলে চালায়, yield-এ আবার নামিয়ে রাখে। এটি একটি coroutine-এর সরল রূপ — যে function নিজে থেমে নিয়ন্ত্রণ ফিরিয়ে দিতে পারে। তবে JavaScript-এর generator “stackless”: থামতে পারে শুধু নিজের body-তে, ভেতরের কোনো সাধারণ function-এর মধ্যে yield লেখা যায় না।

Generator দিয়ে আগের Range কত ছোট হয়, দেখুন। Method-এর নামের আগে * দিলে সেটি generator method:

class Range {
  constructor(start, end, step = 1) { Object.assign(this, { start, end, step }); }
  *[Symbol.iterator]() {
    for (let i = this.start; i <= this.end; i += this.step) yield i;
  }
}
[...new Range(1, 10, 2)];   // [ 1, 3, 5, 7, 9 ]

৫ · অসীম generator, take আর yield*

Array-এর আকার সীমিত — মেমরিতে যতটুকু ধরে। কিন্তু generator একটি মান বানায় কেবল যখন কেউ চায়, তাই while (true) লুপ থাকলেও ভয় নেই: প্রতিটি yield-এ সে থামে, আর কেউ না চাইলে পরের মান কখনো হিসাবই হয় না। এই ধরনের অসীম উৎসের দুটি বাস্তব উদাহরণ:

• অর্ডার id: একটি দোকানের অ্যাপে প্রতিটি নতুন অর্ডারের id চাই — ORD-0001, ORD-0002… কতগুলো লাগবে, কেউ জানে না।
• Fibonacci ক্রম: ০, ১, ১, ২, ৩, ৫… গণিতে এর শেষ নেই।

অসীম উৎস থেকে নিরাপদে কয়েকটি মান নিতে একটি ছোট সহায়ক লাগে — take(source, n), যে nটি মান দিয়ে থেমে যায়। এটিও একটি generator. আর yield* দিয়ে একটি generator আরেকটি iterable-এর সব মান পরপর পার করে দিতে পারে। নিচের কোডে সব একসাথে, শেষ লাইনে ES2025-এর iterator helper-সহ:

function* orderIds() {
  let n = 1;
  while (true) yield "ORD-" + String(n++).padStart(4, "0");
}
function* fib() {
  let [a, b] = [0, 1];
  while (true) { yield a; [a, b] = [b, a + b]; }
}
function* take(source, n) {
  if (n <= 0) return;
  for (const x of source) { yield x; if (--n === 0) return; }
}
function* evens(source) {
  for (const x of source) { console.log("  পরীক্ষা:", x); if (x % 2 === 0) yield x; }
}
function* job() {
  try { yield 1; yield 2; yield 3; } finally { console.log("পরিষ্কার করা হলো"); }
}
const ids = orderIds();
console.log(ids.next().value, ids.next().value);
console.log([...take(fib(), 10)]);
console.log([...take(evens(fib()), 2)]);
const three = take(fib(), 3);
console.log([...three], [...three]);
for (const v of job()) { if (v === 2) break; console.log(v); }
console.log(fib().map((x) => x * 10).take(5).toArray());

yield* — কাজ অন্যকে বুঝিয়ে দেওয়া

yield* (তারকাসহ yield) একটি iterable নিয়ে তার প্রতিটি মান একে একে বাইরে পাঠায়, যেন সেগুলো এই generator নিজেই yield করছে। একটি Playlist যদি কয়েকটি অ্যালবামে ভাগ করা থাকে:

function* playAll(albums) {
  for (const album of albums) {
    yield `— ${album.name} —`;
    yield* album.songs;           // array-ও iterable, তাই চলে
  }
}
const albums = [
  { name: "লোকগীতি", songs: ["ভাটিয়ালি-১", "ভাটিয়ালি-২"] },
  { name: "ব্যান্ড", songs: ["রক-১"] },
];
[...playAll(albums)];
// প্রত্যাশিত আউটপুট: [ '— লোকগীতি —', 'ভাটিয়ালি-১', 'ভাটিয়ালি-২', '— ব্যান্ড —', 'রক-১' ]

৬ · Lazy পাইপলাইন — generator বনাম array

পর্ব ১৬-এ array method দিয়ে পাইপলাইন বানিয়েছেন: orders.filter(…).map(…).slice(0, 2). এটি eager — filter পুরো array শেষ করে একটি নতুন array বানায়, তারপর map আরেকটি, তারপর slice দুটি রেখে বাকি ফেলে দেয়। ১০ লাখ অর্ডার থেকে প্রথম দুটি চাইলে ১০ লাখবার পরীক্ষা হয়।

Generator দিয়ে একই পাইপলাইন lazy: প্রতিটি ধাপ একটি generator, যে আগের ধাপ থেকে একটি মান টানে, কাজ করে, পরের ধাপে পাঠায়। শেষ ধাপ যখন যথেষ্ট পায়, পুরো শিকল থেমে যায়। এখানে ডেটা “ঠেলা” হয় না, “টানা” হয় — শেষ থেকে শুরুর দিকে। নিচে উৎস হলো ১, ২, ৩, ৪… (অসীম), ধাপগুলো: জোড় রাখো → বর্গ করো → প্রথম দুটি নাও।

1const nums = naturals();          // 1, 2, 3, …2const even = filter(nums, isEven);3const sq = map(even, (x) => x * x);4const out = take(sq, 2);5console.log([...out]);

বাস্তবে lazy পাইপলাইন কোথায় লাগে? পণ্যের তালিকা পাতায় পাতায়: একটি দোকানের ১০,০০০ পণ্য থেকে “স্টকে আছে আর দাম ৫০০ টাকার কম” এমন প্রথম ২০টি দেখাতে হবে — lazy হলে সাধারণত শুধু প্রথম কয়েকশো পণ্য পরীক্ষা হয়। বড় ফাইল লাইন ধরে পড়া: ৫ GB-র একটি log ফাইল পুরোটা মেমরিতে তুললে সার্ভার ভেঙে পড়বে; লাইন ধরে টেনে নিলে মেমরিতে থাকে এক সময়ে একটি লাইন। Node.js-এ readline module ঠিক এভাবে লাইন দেয় (পর্ব ৪৯-এ দেখবেন)।

ES2025-এর iterator helper — lazy পাইপলাইন ভাষার ভেতরে

পর্ব ১৬-এর ভাবনার প্রশ্নে দেখেছিলেন, এতদিন lazy পাইপলাইনের জন্য filter, map, take-এর মতো generator নিজে লিখতে হতো। ES2025 থেকে iterator helper এগুলো সরাসরি দেয়: built-in iterator আর সব generator object-এর ওপর .map(), .filter(), .take(), .drop(), .flatMap(), .reduce(), .toArray(), .some(), .every(), .find(), .forEach().

// Edge/Chrome 122+ আর Node 22+ — Node 20-এ নেই
const cheap = products.values()          // array → iterator
  .filter((p) => p.inStock && p.price < 500)
  .map((p) => p.name)
  .take(20)
  .toArray();                            // এখানে এসে তবেই কাজ শুরু

Iterator.from(myIterator).drop(10);      // হাতে লেখা {next} object-কেও helper দেওয়া

৭ · দুই দিকের কথা — next(value), return(), throw() আর finally

এতক্ষণ generator শুধু মান দিয়েছে। কিন্তু yield আসলে একটি expression — এরও একটি মান আছে। next(value)-এ যে মান পাঠান, থেমে থাকা yield expression সেই মান হয়ে যায়। অর্থাৎ generator বাইরে মান পাঠায়, বাইরে থেকে মান নেয়ও। একটি দোকানের ক্যাশ কাউন্টারের চলমান যোগফল দিয়ে দেখুন:

1function* runningTotal() {2  let sum = 0;3  while (true) {4    const x = yield sum;5    sum += x;6  }7}8const till = runningTotal();9till.next();      // শুরু করা10till.next(120);11till.next(80);12till.return();

বাইরে থেকে নিয়ন্ত্রণের তিনটি method এক জায়গায়:

try…finally — কখনো পরিষ্কার না ভুলতে

অংশ ৫-এর কোডে দেখেছেন: for…of মাঝপথে break করলেও generator-এর finally চলেছে। কারণ লুপ আগেভাগে থামলে for…of নিজে থেকেই iterator-এর return() ডাকে। Destructuring-ও তাই করে — const [a] = gen() একটি মান নিয়ে বাকিটা বন্ধ করে দেয়। তাই একটি generator যদি কোনো সম্পদ খোলে (ফাইল, ডেটাবেস cursor, নেটওয়ার্ক সংযোগ), সেটি try { … } finally { বন্ধ করো }-এর ভেতরে রাখুন। ব্যবহারকারী যেভাবেই থামান — শেষ পর্যন্ত, break, বা error — পরিষ্কার হবেই।

৮ · async iterator আর async generator — অপেক্ষা করে আসা মান

এতক্ষণ প্রতিটি মান সাথে সাথে তৈরি হচ্ছিল। কিন্তু অনেক মান আসে সময় নিয়ে — সার্ভার থেকে পাতায় পাতায় পণ্যের তালিকা, নেটওয়ার্ক থেকে টুকরো টুকরো ডেটা, ফাইল থেকে লাইন। এসবের জন্য ES2018-এ এসেছে async iterator: চুক্তি প্রায় একই, শুধু method-এর নাম Symbol.asyncIterator, আর next() সরাসরি { value, done } না দিয়ে একটি Promise দেয়, যা পরে { value, done }-এ পূর্ণ হয়। এগুলো ঘোরার লুপ for await…of, আর সবচেয়ে সহজে বানানোর উপায় async generator — async function*, যার ভেতরে await আর yield দুটোই চলে।

উদাহরণ: একটি API একবারে ৩টি পণ্য দেয়, সাথে জানায় আরও আছে কি না। ব্যবহারকারীর কোডকে পাতার হিসাব জানাতে চাই না — সে শুধু একটির পর একটি পণ্য পাবে। নিচে আসল নেটওয়ার্কের বদলে একটি নকল async function (১০০ মিলিসেকেন্ড পরে উত্তর দেয়):

const PRODUCTS = Array.from({ length: 7 }, (_, i) => `পণ্য-${i + 1}`);
function fakeFetchPage(page) {               // নকল API — পাতায় ৩টি করে
  return new Promise((resolve) => setTimeout(() => resolve({
    items: PRODUCTS.slice((page - 1) * 3, page * 3),
    hasMore: page * 3 < PRODUCTS.length,
  }), 100));
}
async function* allProducts() {
  for (let page = 1; ; page++) {
    const res = await fakeFetchPage(page);   // এখানে অপেক্ষা
    console.log(`পাতা ${page} এল`);
    yield* res.items;                        // পাতার প্রতিটি পণ্য একে একে
    if (!res.hasMore) return;
  }
}
for await (const p of allProducts()) {       // module বা async function-এর ভেতরে
  console.log(p);
  if (p === "পণ্য-4") break;                 // দরকারের বেশি পাতা আনা হয় না
}
// প্রত্যাশিত আউটপুট: পাতা 1 এল, পণ্য-1, পণ্য-2, পণ্য-3, পাতা 2 এল, পণ্য-4

৯ · AI-এর যুগে — AI-এর লেখা iterator আর generator কোড যাচাই

AI-কে “একটি বড় CSV ফাইল থেকে প্রথম ১০টি ভুল লাইন খুঁজে দাও” বললে প্রায়ই পাবেন: পুরো ফাইল একবারে পড়ো, split("\n") দিয়ে array বানাও, তারপর filter আর slice(0, 10). ছোট ফাইলে চলে, ২ GB ফাইলে সার্ভার মেমরি শেষ। Generator-এর বিষয়ে AI-এর সাধারণ ভুলগুলো:

AI-এর লেখা iterator/generator কোড হাতে পেলে — যাচাইয়ের চেকলিস্ট

• বড় বা অসীম ডেটা কোথাও [...x], Array.from বা toArray() দিয়ে পুরোটা array হচ্ছে না — হলে আগে take আছে
• কোনো generator object দুই জায়গায় ঘোরানো হচ্ছে না; বারবার লাগলে iterable class বা নতুন generator
• মান ঘোরার সব লুপ for…of; for…in শুধু object-এর key-এর জন্য
• কোনো সম্পদ খুললে try…finally আছে, আর মাঝপথে break করে নিজে চালিয়ে দেখেছি পরিষ্কার হয় কি না
• দুই দিকের generator-এ প্রথম next() খালি রাখা হয়েছে, আর দরকারি মান return নয়, yield করা
• ব্যবহার করা feature (iterator helper, Iterator.from, top-level for await) লক্ষ্য ব্রাউজার আর Node সংস্করণে চলে
• অসীম generator-এর প্রতিটি ব্যবহারের পাশে একটি থামার শর্ত (take, break, return) চোখে দেখেছি