JavaScript break మరియు continue తెలుగులో | Loop Control Statements

• break తో loop ని మధ్యలోనే ఆపేయడం
• continue తో ఒక రౌండ్ ని మాత్రమే దాటేయడం (skip)
• వాస్తవ ప్రపంచ ఉదాహరణ: Prime Number ని వేగంగా check చేయడం
• Nested loops లో break ఎలా ప్రవర్తిస్తుంది & Labelled break
• continue వల్ల వచ్చే ప్రమాదకరమైన Infinite Loop సమస్య మరియు పరిష్కారం
• Beginners చేసే సాధారణ తప్పులు & సమగ్ర ప్రాక్టీస్ ప్రశ్నలు

Loop తిరుగుతున్నప్పుడు break స్టేట్‌మెంట్ కనిపించగానే, JavaScript ఆ loop ని వెంటనే ముగించి, loop block తర్వాత ఉన్న code కి వెళ్ళిపోతుంది. Loop షరతు ఇంకా true గా ఉన్నా సరే, ఇక ఏ రౌండ్‌నూ తిరగదు.

ఉదాహరణ 1: సాధారణ break

for (let i = 1; i <= 10; i++) {
  if (i === 5) {
    break;
  }
  console.log(i);
}

Code అర్థం చేసుకుందాం:

1. ఈ loop సాధారణంగా 1 నుంచి 10 వరకు తిరగాలి.
2. i విలువ 1, 2, 3, 4 ఉన్నంత వరకు if (i === 5) కండిషన్ false అయ్యింది, కాబట్టి ఆ సంఖ్యలు console లో print అయ్యాయి.
3. i = 5 అయినప్పుడు if (i === 5) కండిషన్ true అయ్యి, లోపల ఉన్న break అమలయ్యింది. దాంతో loop తక్షణమే ఆగిపోయింది.
4. అందుకే 5 print అవ్వలేదు, అలాగే 6 నుంచి 10 వరకు ఉన్న మిగతా రౌండ్లు ఏవీ అసలు రన్ అవ్వలేదు.

ఉదాహరణ 2: తాళం చెవి వెతకడం (Searching in Data)

const correctKey = 4;

for (let key = 1; key <= 10; key++) {
  console.log(`key ${key} try చేస్తున్నాం`);
  if (key === correctKey) {
    console.log("తాళం తెరుచుకుంది!");
    break;
  }
}

సరైన key దొరికిన వెంటనే loop ఆగింది. మిగతా 6 keys ని ప్రయత్నించే వృథా పని తప్పింది. ఇదే break యొక్క అసలు ఉపయోగం: కావాల్సింది దొరికాక, మిగతా పనిని ఆపేయడం. లక్షల రికార్డులున్న పెద్ద డేటాబేస్ లో ఏదైనా వెతికేటప్పుడు ఇది CPU సమయాన్ని మరియు మెమరీని విపరీతంగా ఆదా చేస్తుంది.

ఉదాహరణ 3: while (true) తో break వాడటం

కొన్నిసార్లు "ఎప్పటికీ తిరుగుతూ ఉండు, నేను చెప్పినప్పుడు మాత్రమే ఆగు" అని loop రాస్తారు. దానికి while (true) వాడి, నిర్దిష్ట పరిస్థితి వచ్చినప్పుడు లోపల break పెడతారు.

let n = 1;

while (true) {
  if (n > 3) {
    break;
  }
  console.log(n);
  n++;
}

while (true) అంటే షరతు ఎల్లప్పుడూ true కాబట్టి, break లేకపోతే ఇది అంతులేని loop గా మారిపోతుంది. ఇక్కడ n > 3 అయినప్పుడు break దాన్ని సురక్షితంగా ఆపింది. ఇలాంటి కోడ్ రాసేటప్పుడు ఎప్పుడో ఒకప్పుడు break తప్పక ట్రిగ్గర్ అయ్యేలా చూసుకోవాలి.

continue కనిపించగానే, ఆ రౌండ్ లో మిగిలిన code ని వదిలేసి, నేరుగా తర్వాతి రౌండ్ కి వెళ్తుంది. Loop మాత్రం ఆగదు!

ఉదాహరణ 1: సాధారణ continue

for (let i = 1; i <= 5; i++) {
  if (i === 3) {
    continue;
  }
  console.log(i);
}

i = 3 అయినప్పుడు continue రన్ అయ్యి, ఆ రౌండ్ లో కిందున్న console.log(i) ని దాటేసింది. కానీ loop ఆగలేదు! వెంటనే i = 4 కి వెళ్ళి మిగతా సంఖ్యలను ప్రింట్ చేసింది. అందుకే 3 మాత్రమే మిస్ అయ్యింది.

ఉదాహరణ 2: 3 తో భాగింపబడే సంఖ్యలను దాటేయడం

for (let i = 1; i <= 10; i++) {
  if (i % 3 === 0) {
    continue;
  }
  console.log(i);
}

3, 6, 9 (3 తో భాగింపబడే సంఖ్యలు) వచ్చినప్పుడు శేషం 0 అవుతుంది (i % 3 === 0), కాబట్టి continue అయ్యి అవి ప్రింట్ అవ్వలేదు. (మాడ్యులో % ఆపరేటర్ ని Chapter 5 లో నేర్చుకున్నాం, గుర్తుందా?).

Prime సంఖ్య (ప్రధాన సంఖ్య): 1 మరియు అదే సంఖ్య తప్ప, మరే సంఖ్యతోనూ భాగింపబడని సంఖ్య (ఉదాహరణకు: 2, 3, 5, 7, 11, 13, 17, 19, 23, 29...). ఉదాహరణకు 29 prime, ఎందుకంటే 2 నుంచి 28 వరకు ఏ సంఖ్యతో భాగించినా శేషం 0 రాదు.

ఒక సంఖ్య prime అవునా కాదా చెక్ చేయడానికి, 2 నుంచి (సంఖ్య - 1) వరకు ప్రతి సంఖ్యతో భాగించి చూస్తాం. ఏదైనా ఒక్క సంఖ్యతో భాగింపబడినా, అది prime కాదని వెంటనే తెలిసిపోతుంది! ఇక మిగతా సంఖ్యలను చెక్ చేయాల్సిన అవసరమే లేదు. సరిగ్గా ఇక్కడే break ఎంతో విలువైనది.

const num = 29;
let isPrime = num > 1;

for (let i = 2; i < num; i++) {
  if (num % i === 0) {
    isPrime = false;
    break; // భాగింపబడింది, ఇక మిగతావి చెక్ చేయాల్సిన పనిలేదు!
  }
}

console.log(`${num} ${isPrime ? "prime సంఖ్య" : "prime కాదు"}`);

ఒకవేళ మీరు పైన const num = 15; అని మార్చి రన్ చేస్తే:

Code అర్థం చేసుకుందాం:

1. isPrime ని మొదట true అనుకున్నాం (సంఖ్య 1 కంటే ఎక్కువ ఉంటేనే; అందుకే num > 1. 0, 1 లేదా ఋణ సంఖ్యలు prime కావు).
2. Loop 2 నుంచి num - 1 వరకు తిరుగుతుంది.
3. num % i === 0 అంటే num, i తో పూర్తిగా భాగింపబడింది. అప్పుడు అది prime కాదు, కాబట్టి isPrime = false చేసి break తో వెంటనే లూప్‌ను ఆపాం.
4. 15 కి ఏం జరిగింది?: i = 2 వద్ద (15 % 2 = 1, కాదు), i = 3 వద్ద (15 % 3 = 0, అవును!), అక్కడే break అయ్యింది! 4 నుంచి 14 వరకు 11 రౌండ్లు అనవసరంగా చెక్ చేయకుండా CPU సమయం ఆదా అయ్యింది.
5. 29 కి ఏం జరిగింది?: ఏ i తోనూ భాగింపబడలేదు, కాబట్టి isPrime మొదటిలాగే true గానే ఉండిపోయింది.

break ఎప్పుడూ దానికి అత్యంత దగ్గరగా ఉన్న loop ని మాత్రమే ఆపుతుంది. Nested loops (ఒక loop లోపల ఇంకో loop) ఉన్నప్పుడు, లోపలి loop లో break రాస్తే, లోపలిది మాత్రమే ఆగుతుంది. బయటి loop యథావిధిగా కొనసాగుతుంది.

సాధారణ Nested Loop లో break:

for (let i = 1; i <= 3; i++) {
  for (let j = 1; j <= 3; j++) {
    if (j === 2) {
      break;
    }
    console.log(`i=${i}, j=${j}`);
  }
}

ప్రతిసారీ j = 2 అయినప్పుడు లోపలి loop మాత్రమే ఆగిపోయింది. కానీ బయటి loop (i) 1, 2, 3 అన్నీ తిరిగింది.

Labelled break: బయటి loop ని కూడా ఆపేయడం

ఒకవేళ లోపలి loop లో ఉన్నప్పుడు బయటి loop ని కూడా ఒకేసారి పూర్తిగా ఆపేయాలనుకుంటే, ఆ బయటి loop కి ఒక Label (పేరు) ఇచ్చి, break labelName; అని రాస్తాం.

outer: for (let i = 1; i <= 3; i++) {
  for (let j = 1; j <= 3; j++) {
    if (i === 2 && j === 2) {
      break outer;
    }
    console.log(`i=${i}, j=${j}`);
  }
}

i = 2, j = 2 అయినప్పుడు break outer; రన్ అయ్యింది. అది లోపలి loop నే కాకుండా, outer: అనే పేరున్న బయటి loop ని కూడా శాశ్వతంగా ముగించేసింది. అందుకే i = 3 కి అసలు వెళ్లనే లేదు.

గమనిక: outer: అనేది కేవలం ఒక లేబుల్ పేరు. మీరు దానికి నచ్చిన పేరు పెట్టుకోవచ్చు. అదే విధంగా continue outer; అని రాస్తే, బయటి loop యొక్క తర్వాతి రౌండ్ కి వెళ్తుంది. అయితే labels ని ప్రొఫెషనల్ కోడింగ్ లో చాలా అరుదుగా వాడతారు. ఈ కాన్సెప్ట్ తెలుసుకుంటే చాలు.

1. while loop లో continue కి ముందు counter ని పెంచకపోవడం (Infinite Loop Trap)

Beginners తరచుగా పడే అతిపెద్ద ఉచ్చు ఇది! కింది కోడ్ పరిశీలించండి:

let i = 0;
while (i < 5) {
  if (i === 2) {
    continue;
  }
  console.log(i);
  i++;
}

✅ సరైన పద్ధతి: continue కి ముందే counter ని పెంచండి:

let i = 0;
while (i < 5) {
  i++;
  if (i === 2) {
    continue;
  }
  console.log(i);
}

గమనిక: for loop లో ఈ సమస్య రాదు, ఎందుకంటే continue చేసినా మూడో భాగమైన i++ ఎల్లప్పుడూ ఆటోమేటిక్‌గా రన్ అవుతుంది. while మరియు do-while లలో మాత్రమే మనం జాగ్రత్తగా ఉండాలి.

2. switch లోపల ఉన్న break లూప్‌ను కూడా ఆపుతుందనుకోవడం

for (let i = 1; i <= 3; i++) {
  switch (i) {
    case 2:
      break;
    default:
      console.log(i);
  }
}

i = 2 అయినప్పుడు break రన్ అయ్యింది, కానీ అది కేవలం switch నుంచి మాత్రమే బయటకు తెచ్చింది. for loop కొనసాగి i = 3 ని కూడా ప్రింట్ చేసింది. Switch లోపల ఉన్నప్పుడు మొత్తం loop ని ఆపాలంటే labelled break వాడాలి.

3. Loop బయట break లేదా continue వాడటం

if (true) {
  break;
}

break మరియు continue కేవలం loop ల లోపల (మరియు break కి switch లోపల) మాత్రమే పని చేస్తాయి. సాధారణ if బ్లాక్‌లో వాడితే JavaScript సింటాక్స్ ఎర్రర్ ఇస్తుంది.

4. break బదులు continue వాడటం (లేదా వ్యతిరేకంగా)

కోడ్ రాసేటప్పుడు "ఇక్కడితో పని ముగిసిందా, లూప్ మొత్తం ఆగిపోవాలా? లేక కేవలం ఈ ఒక్క రౌండ్‌ని మాత్రమే వదిలేయాలా?" అని ఆలోచించండి. మొత్తం ఆపాలంటే break, ఈ ఒక్క రౌండ్‌ని దాటవేయాలంటే continue.

5. break తర్వాత కూడా ఆ రౌండ్‌లోని కింది లైన్లు రన్ అవుతాయనుకోవడం

break లేదా continue లైన్ రన్ అయిన మరుక్షణమే కంట్రోల్ జంప్ అయిపోతుంది. ఆ బ్లాక్‌లో వాటి కింద రాసిన కోడ్ ఏదీ ఎప్పటికీ అమలు కాదు. అందుకే వీటిని ఎల్లప్పుడూ if కండిషన్ లోపల రాస్తాం.

కింది సమస్యలకు కోడ్ రాసి మీ అవగాహనను పరీక్షించుకోండి:

1. 50 కంటే పెద్దదైన, 7 తో భాగింపబడే మొదటి సంఖ్యను కనుక్కుని ప్రింట్ చేయండి. (హింట్: 51 నుంచి loop మొదలుపెట్టి, దొరకగానే break చేయండి).
2. 1 నుండి 10 వరకు సంఖ్యలను ప్రింట్ చేయండి, కానీ 5 ని దాటేయండి (skip).
3. 1 నుండి 20 వరకు, కేవలం బేసి (odd) సంఖ్యలను మాత్రమే continue వాడి ప్రింట్ చేయండి.
4. ఒక సంఖ్య prime అవునా కాదా చెక్ చేసే ప్రోగ్రామ్ రాయండి. 21 తో టెస్ట్ చేయండి.
5. 1 నుంచి 10 వరకు సంఖ్యలను కూడుతూ (sum) వెళ్ళండి. మొత్తం కూడిక 20 దాటగానే, ఏ సంఖ్య వద్ద దాటిందో చూపించి loop ఆపండి.

for (let i = 51; i <= 100; i++) {
  if (i % 7 === 0) {
    console.log(i);
    break;
  }
}

for (let i = 1; i <= 10; i++) {
  if (i === 5) {
    continue;
  }
  console.log(i);
}

for (let i = 1; i <= 20; i++) {
  if (i % 2 === 0) {
    continue; // సరి సంఖ్య అయితే స్కిప్
  }
  console.log(i);
}

const num = 21;
let isPrime = num > 1;

for (let i = 2; i < num; i++) {
  if (num % i === 0) {
    isPrime = false;
    break;
  }
}

console.log(`${num} ${isPrime ? "prime సంఖ్య" : "prime కాదు"}`);

let sum = 0;

for (let i = 1; i <= 10; i++) {
  sum += i;
  if (sum > 20) {
    console.log(`i = ${i} వద్ద sum = ${sum} అయ్యింది`);
    break;
  }
}