লুপ — for, while, for…of আর for…in

১ · লুপ কেন — একই কাজ বারবার, শর্ত যতক্ষণ সত্য

আগের পর্বে আপনি if আর switch দিয়ে প্রোগ্রামকে পথ বেছে নিতে শিখিয়েছেন। এবার দ্বিতীয় বড় ক্ষমতা: একই কাজ বারবার করা। একটি অনলাইন দোকানের কার্টে ৩টি পণ্য থাকলে আপনি তিনটি যোগ হাতে লিখতে পারেন। কিন্তু ৩০০টি থাকলে? বা কতগুলো থাকবে আগে জানাই না থাকলে?

এখানেই loop. লুপ হলো এমন একটি গঠন, যা একটি শর্ত যতক্ষণ সত্য থাকে, ততক্ষণ একটি কোড-অংশ (body) বারবার চালায়। প্রতিটি ঘোরাকে বলে একটি iteration. যেকোনো লুপ লেখার আগে তিনটি প্রশ্নের উত্তর জানা চাই:

1. কোথা থেকে শুরু? — প্রথম পণ্য, প্রথম মাস, ১ নম্বর রোল।
2. কখন থামবে? — পণ্য শেষ হলে, টাকা লক্ষ্যে পৌঁছালে, ব্যবহারকারী “শেষ” বললে।
3. প্রতিবার কী বদলাবে? — পরের পণ্যে যাওয়া, মাস এক বাড়ানো। এই বদলই লুপকে থামার দিকে এগিয়ে নেয়।

JavaScript-এ লুপের পাঁচটি রূপ আছে। প্রত্যেকটির নিজের জায়গা — আর ভুল জায়গায় ভুলটি ব্যবহার করাই সবচেয়ে চেনা বাগের উৎস:

২ · for লুপ — শুরু, শর্ত, বদল আর চলার আসল ক্রম

ক্লাস থ্রিতে পড়া ছোট ভাই মিতুলের জন্য ৭-এর নামতা ছাপাতে চান। for লুপ তিনটি প্রশ্নের উত্তর এক লাইনে লিখতে দেয়:

• init — শুরুতে একবারই চলে। সাধারণত এখানে loop variable তৈরি হয়: let i = 1.
• condition — প্রতিটি ঘোরার আগে যাচাই হয়। truthy হলে body চলে, falsy হলে লুপ শেষ (truthy/falsy পর্ব ০৮-এ দেখেছেন)।
• update — প্রতিটি ঘোরার শেষে চলে, যেমন i++.

লেখার ক্রম আর চলার ক্রম এক নয় — update লেখা থাকে শর্তের পাশে, কিন্তু চলে body-র পরে। নামতাটি দুই ঘর পর্যন্ত ছোট করে নিচে ধাপে ধাপে দেখুন। “পরে” চাপলে দাগানো লাইনটি এইমাত্র চলেছে:

1const n = 7;2for (let i = 1; i <= 2; i++) {3  console.log(`${n} × ${i} = ${n * i}`);4}5console.log('শেষ');

আসল নামতার জন্য শর্তটি শুধু i <= 10 করে দিন — বাকি সব এক। তিনটি অংশের যেকোনোটি খালিও রাখা যায়, শুধু দুটি ; থাকতেই হবে: for (;;) মানে “শর্ত নেই, অর্থাৎ সবসময় সত্য” — ইচ্ছাকৃত অসীম লুপ, যা থেকে বেরোতে ভেতরে break লাগবেই। কমা দিয়ে দুটি ভ্যারিয়েবলও চালানো যায়: for (let lo = 0, hi = 9; lo < hi; lo++, hi--) — দুই প্রান্ত থেকে মাঝের দিকে আসার কাজে।

let, const আর var — loop variable কোথায় বাঁচে

let i দিয়ে তৈরি ভ্যারিয়েবলের block scope শুধু লুপের ভেতরে। একই function-এ পাঁচটি লুপ থাকলে পাঁচটিতেই নিশ্চিন্তে i নাম ব্যবহার করা যায়। আর ওপরের ধাপ ৫-এর “প্রতি ঘোরায় নতুন কপি” নিয়মের কারণে লুপের ভেতরে তৈরি কোনো function পরে চললেও সে নিজের ঘোরার i-টাই দেখে।

var দিয়ে লিখলে পুরো লুপে একটাই i, আর সেটি লুপের বাইরেও বেঁচে থাকে। তাই for (var i = 0; i < 3; i++) fns.push(() => i) লিখে পরে তিনটি function চালালে [ 3, 3, 3 ] আসে, let দিলে [ 0, 1, 2 ] (Node-এ চালিয়ে মিলিয়ে দেখা)। এই বিখ্যাত বাগের পুরো ব্যাখ্যা পর্ব ০৭-এ দেখেছেন, আর তার পেছনের যন্ত্র — closure — আসবে পর্ব ২২-এ।

৩ · while আর do…while — কখন থামবে আগে জানা নেই

সুমাইয়া একটি ল্যাপটপ কেনার জন্য প্রতি মাসে ১,৫০০ টাকা জমাবেন, লক্ষ্য ১০,০০০ টাকা। কত মাস লাগবে? এখানে আমরা ঘোরার সংখ্যা আগে জানি না — সেটাই তো প্রশ্ন। জানি শুধু থামার শর্ত। এমন জায়গায় while:

const goal = 10000;
const perMonth = 1500;
let saved = 0;
let month = 0;

while (saved < goal) {      // শর্ত আগে, তারপর body
  saved += perMonth;
  month++;
}
console.log(`${month} মাসে জমবে ${saved} টাকা`);
// প্রত্যাশিত আউটপুট: 7 মাসে জমবে 10500 টাকা

while-এ শুধু শর্ত লেখা থাকে। শুরু (init) থাকে লুপের আগে, আর বদল (update) থাকে body-র ভেতরে — আপনার দায়িত্বে। body থেকে saved += perMonth বাদ দিলে saved চিরকাল 0, শর্ত চিরকাল সত্য — অসীম লুপ। প্রতিটি while লেখার পর নিজেকে জিজ্ঞেস করুন: “body-র কোন লাইনটি শর্তকে মিথ্যার দিকে নিচ্ছে?”

Sentinel — “থামো” বোঝানোর বিশেষ মান

একটি দোকানের ক্যাশিয়ার একের পর এক দাম ঢোকান; দিনের শেষে 0 ঢোকালে বোঝা যায় “আর নেই”। এমন বিশেষ মানকে বলে sentinel — পাহারাদার। কতগুলো দাম আসবে আগে জানা নেই, শুধু জানি শেষটা কেমন দেখতে:

const entries = [250, 120, 80, 0, 999];   // 0 = দিনের শেষ
let i = 0;
let sum = 0;
while (entries[i] !== 0) {
  sum += entries[i];
  i++;
}
console.log(sum);   // প্রত্যাশিত আউটপুট: 450 — 999 কখনো পড়াই হয়নি

Sentinel-এর একটি ঝুঁকি আছে: তালিকায় যদি কখনো 0 না থাকে? i বাড়তে বাড়তে array-র বাইরে যাবে, entries[i] হবে undefined, আর undefined !== 0 সবসময় সত্য — অসীম লুপ। নিরাপদ রূপ: while (i < entries.length && entries[i] !== 0). বাস্তবে sentinel-এর পরিচিত উদাহরণ হলো C-র string-এর শেষে '\0', বা ফাইল পড়ার সময় “আর কিছু নেই” সংকেত।

do…while — আগে কাজ, পরে প্রশ্ন

do…while-এ শর্ত যাচাই হয় body-র পরে। তাই body অন্তত একবার চলবেই। কোথায় কাজে লাগে? যেখানে প্রশ্ন করার আগে একবার কাজটি করতেই হবে — একটি মেনু দেখানো, বা নেটওয়ার্ক কল একবার চেষ্টা করে দেখা সফল হলো কি না:

let attempt = 0;
let ok;
do {
  attempt++;
  ok = trySendSms(attempt);       // কাল্পনিক function: সফল হলে true
} while (!ok && attempt < 3);     // ব্যর্থ হলে আবার — সর্বোচ্চ ৩ বার
console.log(ok ? `${attempt} বারে পাঠানো গেল` : 'পাঠানো গেল না');

লক্ষ করুন attempt < 3 — আবার চেষ্টার লুপে সবসময় একটি সর্বোচ্চ সীমা রাখুন। নইলে সার্ভার বন্ধ থাকলে লুপ কখনো থামবে না। আর while (…);-এর শেষে সেমিকোলন do…while-এর ব্যাকরণের অংশ। সত্যিকারের নেটওয়ার্ক কল async হয় — সেখানে আবার চেষ্টার নকশা (retry, backoff) পর্ব ৩৬-এ।

৪ · for…of — মানের ওপর হাঁটা: array, string, Map আর Set

বাস্তব কোডের বেশিরভাগ লুপের কাজ একটাই: “এই তালিকার প্রতিটি জিনিস নিয়ে কিছু করো”। সেখানে index (i), শর্ত (i < arr.length) আর বদল (i++) — তিনটিই আসলে বাড়তি ঝামেলা, আর তিনটিতেই ভুলের সুযোগ। for…of এগুলো সরিয়ে দেয়:

const prices = [320, 145, 199];
for (const price of prices) {
  console.log(price);      // 320, তারপর 145, তারপর 199
}

এখানে কোনো index নেই, তাই index-এর ভুলও নেই। Index সত্যিই দরকার হলে (যেমন “১. চাল, ২. ডাল” ছাপাতে) লিখুন for (const [i, item] of items.entries()) — array-র entries() জোড়া দেয় [index, মান], আর [i, item] সেটি দুই ভাগে খুলে নেয় (destructuring, পর্ব ১৭)।

কে কে “iterable”?

for…of শুধু array-র জন্য নয়। যে জিনিস একটি নির্দিষ্ট চুক্তি মানে — “আমাকে জিজ্ঞেস করলে আমি একটি একটি করে মান দেব” — সেটিই iterable. এই চুক্তির নাম iteration protocol: জিনিসটির [Symbol.iterator]() নামে একটি method থাকে, যা একটি iterator ফেরত দেয়; iterator-এর next() প্রতিবার দেয় { value, done }. for…of ভেতরে ভেতরে ঠিক এটাই করে — done: true না আসা পর্যন্ত next() ডাকে। নিজের iterable আর generator বানানো দেখবেন পর্ব ২৭-এ।

বাংলা শব্দের ওপর হাঁটা — code point আর “অক্ষর”-এর পার্থক্য

পর্ব ০৯-এ দেখেছেন, JavaScript-এর string ভেতরে UTF-16 code unit-এর সারি, আর .length গোনে code unit. পুরোনো ধাঁচের for (let i = 0; i < s.length; i++) s[i] তাই একটি emoji-কে দুই টুকরো করে ফেলে — দুটি অর্থহীন অর্ধেক। for…of string-কে হাঁটে code point ধরে, তাই 👍 একটি গোটা মান হিসেবেই আসে ([...'👍'].length হলো 1, কিন্তু '👍'.length হলো 2).

কিন্তু code point মানেই পাঠকের চোখের “একটি অক্ষর” নয়। 'বাংলা'-র ওপর for…of চালালে আসে পাঁচটি মান: ব, া, ং, ল, া — আকার-চিহ্ন (া) আলাদা হয়ে যায়, যদিও আমরা “বা”-কে একটি অক্ষর হিসেবে পড়ি। যুক্তাক্ষরে (যেমন “ক্ষ” = ক + ্ + ষ) আরও বেশি টুকরো। চোখের অক্ষর ধরে গুনতে চাইলে লাগে Intl.Segmenter — পর্ব ০৯-এ এর বিস্তারিত দেখেছেন। নিয়ম: emoji বা বাংলা থাকলে index-এর লুপ নয়, অন্তত for…of; আর “অক্ষর” গোনা জরুরি হলে Segmenter.

৫ · for…in — key-র ওপর হাঁটা, আর কেন array-তে কখনো নয়

for…in JavaScript-এর প্রথম সংস্করণ (১৯৯৫) থেকেই আছে। এটি একটি object-এর key — property-র নাম — একটি একটি করে দেয়, string হিসেবে। কোন key আসবে? যেসব property enumerable (গোনার যোগ্য বলে চিহ্নিত), সেগুলো — object-এর নিজের তো বটেই, prototype chain থেকে উত্তরাধিকারে পাওয়া enumerable property-ও। Object নিয়ে বিস্তারিত পর্ব ১৪-এ, prototype পর্ব ২৫-এ।

নামের মিল দেখে for…of আর for…in গুলিয়ে ফেলা JavaScript-এর সবচেয়ে চেনা বাগগুলোর একটি — বিশেষ করে যাঁরা Python থেকে আসেন, যেখানে for x in list মান দেয়। একই array-র ওপর দুটো চালিয়ে পার্থক্যটা নিজের চোখে দেখুন:

const letters = ['ক', 'খ'];
letters.extra = 'গ';

// ভেতরে আসলে এমন একটি object:
//   "0"     → 'ক'
//   "1"     → 'খ'
//   "extra" → 'গ'      (enumerable)
//   length  → 2        (enumerable নয়)

for (const v of letters) console.log(v);

ক
খ
// 'গ' আসেনি: array-র iterator শুধু 0..length-1 দেয়

for (const k in letters) console.log(k);

0
1
extra
// বাড়তি property-ও চলে এলো

for (const k in letters) console.log(k + 1);

01
11
extra1
// typeof k === 'string' → + জোড়া দিল

// কোনো পুরোনো লাইব্রেরি সব array-তে method যোগ করল:
Array.prototype.shuffle = function () { /* … */ };

for (const k in ['ক']) console.log(k);
0
shuffle      // ← আপনার array-তে এটা কোথা থেকে?

// array-র মান:           for (const v of letters)
// array-র index + মান:   for (const [i, v] of letters.entries())
// object-এর key + মান:   for (const [k, v] of Object.entries(obj))
// for…in লাগলেই:         if (Object.hasOwn(obj, k)) { … }

এবার নিজে চালিয়ে দেখুন — একই array-র ওপর দুই লুপ, আর একটি বাংলা শব্দের ওপর for…of:

const letters = ['ক', 'খ'];
letters.extra = 'গ';            // array-তে একটি বাড়তি property

for (const value of letters) console.log('of →', value);
for (const key in letters) console.log('in →', key, typeof key);

const word = 'বাংলা';
let count = 0;
for (const ch of word) {
  console.log(count, ch);
  count++;
}
console.log('code point:', count, '| length:', word.length);
console.log('👍 →', [...'👍'].length, 'বনাম', '👍'.length);

Object ঘোরার আধুনিক উপায় — Object.keys, values, entries

ধরুন একটি কোম্পানির জেলাভিত্তিক বিক্রি একটি object-এ: { 'ঢাকা': 52000, 'চট্টগ্রাম': 31000 }. এর ওপর ঘুরতে তিনটি সহায়ক function আছে, তিনটিই একটি array ফেরত দেয় — আর array-র ওপর তো for…of চলেই:

তিনটিই শুধু object-এর নিজের enumerable property দেয় — উত্তরাধিকারের কিছু নয়। তাই hasOwn-এর পাহারা লাগে না, key-গুলো আলাদা array-তে থাকায় দরকার হলে সাজানো বা ছাঁকাও যায়। আধুনিক কোডে object ঘোরার ডিফল্ট উপায় এটাই: for (const [district, amount] of Object.entries(sales)). অংশ ৮-এ এটি একটি চালানো যায় এমন উদাহরণে দেখবেন।

৬ · break, continue আর labeled break — লুপের লাগাম

কখনো কাজ শেষ হয়ে যায় লুপ শেষ হওয়ার আগেই। গুদামের তালিকায় প্রথম যে পণ্যের স্টক শূন্য, সেটি পেলেই হলো — বাকি ৫০০টি দেখার দরকার নেই। break সঙ্গে সঙ্গে সবচেয়ে ভেতরের লুপ (বা switch) থেকে বের করে দেয়।

আবার কখনো শুধু একটি ঘোরা বাদ দিতে চান — বাতিল হওয়া অর্ডারগুলো হিসাবে না ধরে বাকিগুলো যোগ করা। continue বর্তমান ঘোরার বাকি অংশ ফেলে সোজা পরের ঘোরায় যায়। for লুপে continue-এর পর update (i++) ঠিকই চলে; কিন্তু while-এ update যদি body-র শেষে থাকে, continue তাকে টপকে যায় — আর লুপ একই জায়গায় আটকে অসীম হয়ে যায়। এটি একটি চেনা ফাঁদ।

const orders = [
  { id: 101, amount: 500, cancelled: false },
  { id: 102, amount: 900, cancelled: true },
  { id: 103, amount: 300, cancelled: false },
];
let revenue = 0;
for (const order of orders) {
  if (order.cancelled) continue;    // এই ঘোরার বাকিটা বাদ
  revenue += order.amount;
}
console.log(revenue);   // প্রত্যাশিত আউটপুট: 800

continue-এর বদলে if (!order.cancelled) { … } লিখলেও একই ফল। লম্বা body-তে শুরুতেই “বাদ দেওয়ার শর্তগুলো” continue দিয়ে সেরে ফেলা — একে বলে guard clause — কোডকে কম ইন্ডেন্টে, বেশি পরিষ্কার রাখে।

লুপের ভেতরে লুপ — আর label দিয়ে একসাথে বেরোনো

একটি দোকানের তাক সারি আর কলামে সাজানো — একটি array-র ভেতরে আরও array. “ডাল” কোন তাকে আছে, খুঁজতে দুটি লুপ লাগে: বাইরেরটি সারি ধরে, ভেতরেরটি কলাম ধরে। সমস্যা হলো, সাধারণ break শুধু ভেতরের লুপ থামায় — বাইরের লুপ পরের সারিতে খোঁজা চালিয়েই যায়। সমাধান: বাইরের লুপের সামনে একটি label (নাম আর কোলন), আর break label:

1const shelves = [['চাল', 'তেল'], ['ডাল', 'চিনি'], ['লবণ', 'আটা']];2let found = null;3search: for (let r = 0; r < shelves.length; r++) {4  for (let c = 0; c < shelves[r].length; c++) {5    if (shelves[r][c] === 'ডাল') { found = [r, c]; break search; }6  }7}8console.log(found);

একইভাবে continue search লিখলে ভেতরের লুপের বাকিটা বাদ দিয়ে বাইরের লুপের পরের ঘোরায় যাওয়া যায়। তবে label সচরাচর লাগে না, আর বেশি label কোড পড়া কঠিন করে। পরিষ্কার বিকল্প প্রায়ই আছে: খোঁজার অংশটি একটি function-এ রেখে পাওয়ামাত্র return (function পরের পর্বে)।

৭ · লুপের তিন চেনা ফাঁদ — অসীম লুপ, off-by-one আর ঘোরার মাঝে array বদলানো

ফাঁদ ১ — অসীম লুপ আর জমে যাওয়া পাতা

যে লুপের শর্ত কখনো মিথ্যা হয় না, সেটি infinite loop. C বা Java-তে এটি “প্রোগ্রাম আটকে গেছে” — terminal-এ Ctrl+C চাপলেই মুক্তি। Browser-এ এর ফল আরও নাটকীয়। পর্ব ০৫-এ দেখেছেন, একটি পাতার JavaScript চলে একটিমাত্র thread-এ (single-threaded) — আর সেই একই main thread বোতামের ক্লিক সামলায়, পাতা আঁকে, স্ক্রল করে। আপনার লুপ যতক্ষণ চলছে, event loop পরের কোনো কাজে হাত দিতে পারে না:

// ⚠ চালাবেন না — পাতা পুরোপুরি জমে যাবে
let stock = 5;
while (stock > 0) {
  console.log('বিক্রি হলো');
  // stock-- ভুলে গেছি → শর্ত চিরকাল সত্য
}

এই কোড চললে বোতাম চাপলে সাড়া নেই, স্ক্রল হয় না, কিছুক্ষণ পর Chrome বা Edge “Page Unresponsive” বলে পাতা বন্ধ করার প্রস্তাব দেয়। এই পর্বের runner-এ এমন কোড চালাবেন না — runner-ও একই পাতার ভেতরে চলে। অসীম লুপ নিজেই সবসময় ভুল নয়: সার্ভার বা গেমের মূল লুপ ইচ্ছা করেই অসীম। কিন্তু তাদের প্রতিটির ভেতরে বেরোনোর পথ (break/return) থাকে, আর browser-এ এমন দীর্ঘ কাজ চলে await-এর ফাঁকে ফাঁকে বা আলাদা Web Worker-এ (পর্ব ৪২) — main thread আটকে নয়।

ফাঁদ ২ — Off-by-one: একটি বেশি বা একটি কম

৫টি জিনিসের array-র index 0 থেকে 4. শর্তে <-এর জায়গায় <= লিখলেই একটি বাড়তি ঘোরা, যেখানে arr[5] হলো undefined:

const marks = [78, 85, 62];
let sum = 0;
for (let i = 0; i <= marks.length; i++) sum += marks[i];
console.log(sum);   // NaN — শেষ ঘোরায় 225 + undefined

এই ভুলের নাম off-by-one error. JavaScript এখানে কোনো error দেয় না — C-র মতো মেমরি নষ্ট করে না, Java-র মতো exception ছোড়ে না; চুপচাপ undefined দেয়, আর হিসাব হয়ে যায় NaN. প্রতিরোধের তিনটি অভ্যাস: (১) index লাগলে প্রায় সবসময় i = 0; i < arr.length — “শূন্য থেকে, length-এর কম”; (২) সম্ভব হলে index-ই বাদ — for…of; (৩) সীমানার মানগুলো হাতে যাচাই — খালি array, এক উপাদানের array, আর শেষ উপাদানে কী হয়।

ফাঁদ ৩ — ঘোরার মাঝে array বদলানো

একটি তালিকা থেকে সব 2 মুছতে চান। স্বাভাবিক মনে হয় এভাবে লেখা:

const a = [1, 2, 2, 3];
for (let i = 0; i < a.length; i++) {
  if (a[i] === 2) a.splice(i, 1);   // index i-তে একটি মুছে ফেলো
}
console.log(a);   // [ 1, 2, 3 ] — একটি 2 রয়ে গেল!

কেন? i = 1-এ প্রথম 2 মুছতেই পরের সবাই এক ঘর বাঁয়ে সরে এল — দ্বিতীয় 2 এখন index 1-এ। কিন্তু লুপ ততক্ষণে i++ করে index 2-তে চলে গেছে, তাই সরে আসা 2-টিকে আর দেখা হলো না (Node-এ চালিয়ে দেখা ফল)। for…of-এও একই সমস্যা, কারণ array-র iterator-ও ভেতরে একটি index ধরে এগোয়; আর ঘোরার মাঝে push করলে for…of নতুন উপাদানগুলোও দেখে — প্রতি ঘোরায় push করলে লুপ কখনো শেষই হবে না। নিরাপদ উপায়: (ক) নতুন array বানানো — a.filter(x => x !== 2) (পর্ব ১৬); (খ) পেছন থেকে ঘোরা — for (let i = a.length - 1; i >= 0; i--), যাতে মুছলে যে উপাদানগুলো সরে, সেগুলো আগেই দেখা হয়ে গেছে।

৮ · Accumulator প্যাটার্ন, বাস্তব উদাহরণ আর লুপ বনাম array method

লুপের সবচেয়ে প্রচলিত ব্যবহার একটি ছকে পড়ে: লুপের আগে একটি ভ্যারিয়েবল শুরু-মান নিয়ে তৈরি হয় (যোগফলের জন্য 0, লেখার জন্য '', তালিকার জন্য []), প্রতিটি ঘোরায় তাতে কিছু যোগ হয়, আর লুপের পরে সেটিই ফল। একে বলে accumulator প্যাটার্ন — হিসাবের খাতার মতো, প্রতিটি লেনদেনে শুধু চলতি মোট আপডেট। নিচের উদাহরণে তিনটি বাস্তব কাজ — কার্টের মোট, প্রথম স্টক-শেষ পণ্য খুঁজে break, আর জেলাভিত্তিক বিক্রি Object.entries দিয়ে পড়া:

const cart = [
  { name: 'চাল', price: 320, stock: 12 },
  { name: 'ডাল', price: 145, stock: 0 },
  { name: 'তেল', price: 199, stock: 5 },
];
let total = 0;                          // accumulator
for (const item of cart) total += item.price;
console.log('কার্টের মোট:', total);

let firstOut = null;
for (const item of cart) {
  if (item.stock === 0) { firstOut = item.name; break; }
}
console.log('প্রথম স্টক-শেষ পণ্য:', firstOut);

const sales = { 'ঢাকা': 52000, 'চট্টগ্রাম': 31000, 'রাজশাহী': 18500 };
let report = '';
for (const [district, amount] of Object.entries(sales)) {
  report += `${district}=${amount} `;
}
console.log(report.trim());

লুপ নাকি array method — forEach, map, find

পর্ব ১৬-এ দেখবেন, array-র নিজের method দিয়ে অনেক লুপ এক লাইনে লেখা যায়: যোগফল reduce, ছাঁকা filter, রূপান্তর map, আর “প্রথম যেটি মেলে” — cart.find(item => item.stock === 0). এগুলো উদ্দেশ্য সরাসরি বলে দেয়, তাই পড়তে সহজ। তবে একটি বড় পার্থক্য মনে রাখুন:

এক ঝলক সামনে — for await…of

কিছু ডেটা একবারে আসে না, টুকরো টুকরো আসে — নেটওয়ার্ক থেকে আসা ফাইল, বা একটি API-র পাতার পর পাতা। এদের ওপর ঘোরার জন্য ES2018-এ যুক্ত হয়েছে for await (const chunk of stream) — প্রতিটি মানের জন্য অপেক্ষা করে, তারপর body চালায়। Promise আর async/await না জেনে এর মানে পুরো বোঝা যাবে না, তাই বিস্তারিত পর্ব ৩৪-এ। এখন শুধু মনে রাখুন: async কাজ একটির পর একটি করতে forEach নয়, লুপ।

লুপের গতি — মাইক্রো-বেঞ্চমার্ক নয়, অভ্যাস

ইন্টারনেটে অনেক পুরোনো পরামর্শ পাবেন — “arr.length একটি ভ্যারিয়েবলে রেখে দিন”, “উল্টো দিকে ঘোরান, দ্রুত হয়”। আধুনিক engine (V8, SpiderMonkey, JavaScriptCore) সরল লুপ নিজেই চিনে নেয়: বারবার চলা কোড JIT compiler machine code-এ রূপান্তর করে, অপ্রয়োজনীয় যাচাই সরিয়ে দেয়। একটি সাধারণ for, for…of আর forEach-এর পার্থক্য প্রায় সব বাস্তব প্রোগ্রামে নগণ্য। গতির আসল পার্থক্য আসে অ্যালগরিদম থেকে — লুপের ভেতরে লুপ (১,০০০ × ১,০০০ = ১০ লাখ ঘোরা), বা প্রতি ঘোরায় পাতার DOM ছোঁয়া। মাপতে চাইলে DevTools-এর Performance প্যানেল (পর্ব ৫৩) — অনুমান নয়।

৯ · AI-এর যুগে — AI-এর লেখা লুপ যাচাই

“একটা array-র সব দাম যোগ করার কোড দাও” — AI মুহূর্তে লুপ লিখে দেবে, আর সাধারণ পরীক্ষায় সেটি চলবেও। কিন্তু লুপের ভুল প্রায়ই সীমানায় লুকিয়ে থাকে — খালি array, শেষ উপাদান, বা যে ডেটায় সন্ধান মেলে না। পুরোনো টিউটোরিয়াল আর নানা ভাষার কোড থেকে শেখা AI-এর চেনা ভুলগুলো:

AI-এর লুপ হাতে পেলে — যাচাইয়ের চেকলিস্ট

• প্রতিটি লুপের তিন প্রশ্নের উত্তর নিজে খুঁজে পেয়েছি — শুরু, থামার শর্ত, আর কোন লাইন শর্তকে মিথ্যার দিকে নেয়
• Array-তে for…in নেই; object-এ for…in থাকলে Object.hasOwn আছে বা Object.entries-এ বদলেছি
• যেখানে আগেভাগে থামা দরকার, সেখানে forEach নেই
• খালি array, এক উপাদানের array আর “মিল নেই” — তিনটি সীমানার ক্ষেত্রে চালিয়ে দেখেছি
• প্রতিটি while (true) আর retry লুপে বেরোনোর পথ ও সর্বোচ্চ সীমা আছে
• লুপের ভেতরে যে array ঘুরছি, সেটিকেই বদলানো (splice/push) হচ্ছে না