কোন loop, আর কখন if-এর চেয়ে switch ভালো

তিনটা দাম, ছয় ভাবে হাঁটা। prices.length মানে array-তে কয়টা item, আর prices[i] মানে i নম্বর position-এর item, গোনা শুরু 0 থেকে (Module 7)।

const prices = [120, 450, 1300];
const out = [];

let line = "for:";
for (let i = 0; i < prices.length; i++) {
  line += " " + i + "=" + prices[i];
}
out.push(line);

line = "while:";
let w = 0;
while (w < prices.length) {
  line += " " + prices[w];
  w++;
}
out.push(line);

line = "do...while:";
let d = 0;
do {
  line += " " + prices[d];
  d++;
} while (d < prices.length);
out.push(line);

line = "for...of:";
for (const price of prices) {
  line += " " + price;
}
out.push(line);

line = "for...in:";
for (const key in prices) {
  line += " " + key + " (" + typeof key + ")";
}
out.push(line);

line = "forEach:";
prices.forEach((price, index) => {
  line += " " + index + "=" + price;
});
out.push(line);

console.log(out.join("\n"));

for: 0=120 1=450 2=1300
while: 120 450 1300
do...while: 120 450 1300
for...of: 120 450 1300
for...in: 0 (string) 1 (string) 2 (string)
forEach: 0=120 1=450 2=1300

For loop আর forEach index হাতে তুলে দেয়; while loop দুটোতে index নিজেকে রাখতে হয়। সবচেয়ে ছোট for...of, কারণ কাজটাই "প্রতিটা value"। for...in দেয় key, আর typeof দেখায় প্রতিটা key একটা string, number না। এটা একটা যোগফলের কী দশা করে, দেখাবে common mistake 4।

প্রতিটা test একই value-কে একটা করে constant-এর সাথে মেলায়।

const out = [];
for (const size of ["S", "M", "L", "XL", "constructor"]) {
  let ml;
  if (size === "S") {
    ml = 250;
  } else if (size === "M") {
    ml = 350;
  } else if (size === "L") {
    ml = 500;
  } else {
    ml = "unknown";
  }
  out.push(size + ": " + ml);
}
console.log(out.join("\n"));

S: 250
M: 350
L: 500
XL: unknown
constructor: unknown

কাজ করে, কিন্তু size === লেখা হয়েছে তিনবার। গড়নটা বলছে "এক value, অনেক constant", আর switch ঠিক এই কাজের জন্যই।

Value-টার নাম আসে একবারই, আর প্রতিটা case-এ থাকে একটা constant।

const out = [];
for (const size of ["S", "M", "L", "XL", "constructor"]) {
  let ml;
  switch (size) {
    case "S":
      ml = 250;
      break;
    case "M":
      ml = 350;
      break;
    case "L":
      ml = 500;
      break;
    default:
      ml = "unknown";
  }
  out.push(size + ": " + ml);
}
console.log(out.join("\n"));

S: 250
M: 350
L: 500
XL: unknown
constructor: unknown

Output একই। পাঠক এক নজরেই দেখে, test হচ্ছে শুধু size। দাম দিতে হয় প্রতিটা case-এ একটা করে break, আর একটা বাদ পড়লেই আসল bug, সেজন্যই linter এদিকে নজর রাখে।

মাপ থেকে ml-এর জোড়াগুলো এবার data। { S: 250, M: 350, L: 500 } একটা object, মানে নাম দেওয়া কয়েকটা value-র একটা সেট, আর cupMl[size] পড়ে size যে নামটা বলে, সেই value; object শেখাবে Module 8। Object.hasOwn(cupMl, size) জিজ্ঞেস করে, নামটা object-এর নিজের কিনা।

const cupMl = { S: 250, M: 350, L: 500 };
const out = [];
for (const size of ["S", "M", "L", "XL", "constructor"]) {
  const ml = Object.hasOwn(cupMl, size) ? cupMl[size] : "unknown";
  out.push(size + ": " + ml);
}
console.log(out.join("\n"));

S: 250
M: 350
L: 500
XL: unknown
constructor: unknown

Loop-এর body এক লাইনের, আর নতুন একটা মাপ মানে আরেকটা entry, আরেকটা branch না। Guard-টা আছে Zara-র edge case-এর জন্য। প্রতিটা object prototype থেকে এমন কয়েকটা নাম inherit করে, যেগুলো সে কখনো লেখেনি, constructor তার একটা, তাই cupMl["constructor"] undefined-এর বদলে একটা function খুঁজে পায়। Object.hasOwn না থাকলে শেষ লাইনে print হতো constructor: function Object() { [native code] }।

দশ লাখের কাছাকাছি তিনটা সংখ্যা, প্রতিটা তিন ভাবে যাচাই। Counter-গুলো লিখে রাখে, কোন উপায়ে কয়টা ভাগ হলো।

const out = [];
for (const n of [999983, 999999, 1000000]) {
  let noBreak = 0;
  let isPrime = true;
  for (let d = 2; d < n; d++) {
    noBreak++;
    if (n % d === 0) {
      isPrime = false;
    }
  }

  let withBreak = 0;
  for (let d = 2; d < n; d++) {
    withBreak++;
    if (n % d === 0) {
      break;
    }
  }

  let withRoot = 0;
  for (let d = 2; d * d <= n; d++) {
    withRoot++;
    if (n % d === 0) {
      break;
    }
  }

  out.push(n + (isPrime ? " prime" : " composite") + ": no break " + noBreak + ", break " + withBreak + ", break and root " + withRoot);
}
console.log(out.join("\n"));

999983 prime: no break 999981, break 999981, break and root 998
999999 composite: no break 999997, break 2, break and root 2
1000000 composite: no break 999998, break 1, break and root 1

দুই রকম বের হওয়া দুই রকম সংখ্যার কাজে লাগে। Composite সংখ্যার বেলায় break প্রায় দশ লাখ ভাগকে নামিয়ে আনে এক-দুইটায়, কিন্তু prime-এর কোনো উপকার করতে পারে না, কারণ ওর খুঁজে পাওয়ার মতো কোনো ভাজকই নেই। বর্গমূলের test সাহায্য করে prime-কে: 999,981-এর জায়গায় 998টা ভাগ। দুটো মিলে দুই case-ই সামলায়, আর কোনোটাই উত্তর বদলায় না।

Amara-র loop, কতদূর পড়ল দেখাতে একটা counter-সহ, পাশে find।

const orders = [120, 450, 1300, 80, 2500, 60];
const limit = 1000;
const out = [];

let looked = 0;
let first;
for (const amount of orders) {
  looked++;
  if (amount > limit) {
    first = amount;
    break;
  }
}
out.push("for...of with break: " + first + ", looked at " + looked);

const found = orders.find((amount) => amount > limit);
out.push("find: " + found);

console.log(out.join("\n"));

for...of with break: 1300, looked at 3
find: 1300

Loop ছয়টা order-এর তিনটা পড়ে থেমে যায়। find ফেরত দেয় প্রথম সেই item, যার জন্য arrow function true বলে, আর সে-ও ওখানেই থামে। Kenji-র forEach version আর তার আসল output দেখাবে common mistake 2।