JavaScript break va continue: sikldan erta chiqish va label'lar

Qisqacha: break siklni darhol va butunlay to'xtatadi. continue esa faqat joriy aylanishni tashlab, keyingisiga o'tadi. Ikkalasi ham faqat o'zi turgan eng yaqin siklga ta'sir qiladi. Ichma-ich sikllardan birdaniga chiqish uchun tashqi siklga nom (label) beriladi: break tashqi.

Bu darsda

• break bilan sikldan erta chiqa olasiz va qidiruvni natija topilgan zahoti to'xtata olasiz.
• continue bilan keraksiz aylanishni o'tkazib yubora olasiz.
• while (true) va break naqshini ishlata olasiz.
• Label bilan ichma-ich sikldan birdaniga chiqa olasiz va uning muqobillarini bilasiz.
• continue sababli yuzaga keladigan cheksiz siklni taniysiz.

Oldin bilishingiz kerak: for sikli, while va do...while, switch.

1. Nega bu kerak?

Uydan chiqishdan oldin kalitni qidiryapsiz. Birinchi cho'ntak — yo'q. Ikkinchisi — yo'q. Uchinchi cho'ntakda topdingiz. Endi qolgan 5 ta cho'ntakni ham titkilab chiqasizmi? Albatta yo'q. Topdingiz — qidiruv tugadi.

Boshqa vaziyat. Bozorda olma saralayapsiz. Chirigan olmani ko'rsangiz, savatga solmaysiz. Lekin saralashni to'xtatmaysiz — keyingi olmaga o'tasiz.

Oldingi darslardagi sikllar bunday qila olmaydi. Ular shart false bo'lguncha qaysarlik bilan aylanaveradi. Siklni o'rtada boshqarish uchun ikkita kalit so'z bor:

2. break — sikldan chiqish

2.1 Birinchi misol

break — inglizchada "sindirish, uzish". U siklni o'sha zahoti uzadi:

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

console.log("Sikldan chiqdik");

Konsolda:

1
2
3
Sikldan chiqdik

Sikl 10 gacha aylanishi kerak edi. Lekin i 4 ga teng bo'lganda break ishladi. Shu ondayoq:

• tananing qolgan qismi (console.log(i)) bajarilmadi — shuning uchun 4 chiqmadi;
• qadam (i++) ham, shart ham boshqa tekshirilmadi;
• dastur siklning } qavsidan keyingi qatorga sakradi.

2.2 Qidiruvda erta to'xtash

break ning eng ko'p ishlatiladigan joyi — qidiruv. Parolda raqam bormi? Birinchi raqamni topgan zahoti javob ma'lum — qolgan belgilarni tekshirish shart emas:

const parol = "bahor2026yoz";
let raqamJoyi = -1;

for (let i = 0; i < parol.length; i++) {
  if (parol[i] >= "0" && parol[i] <= "9") {
    raqamJoyi = i;
    break;
  }
}

console.log(raqamJoyi); // 5

Bu kodni birma-bir ko'raylik:

• raqamJoyi = -1 — "hali topilmadi" degan boshlang'ich qiymat. Indeks hech qachon manfiy bo'lmaydi, shuning uchun -1 bilan chalkashmaydi.
• parol[i] >= "0" && parol[i] <= "9" — belgi "0" va "9" oralig'idami? Satrlarni solishtirishni taqqoslash darsida ko'rgansiz.
• Birinchi raqam ("2") 5-indeksda topildi. break — sikl tugadi.

Parol 12 belgidan iborat, lekin sikl faqat 6 marta aylandi. Parol ming belgili bo'lsa ham, raqam boshida bo'lsa, sikl bir necha qadamda tugaydi. Katta ma'lumotlarda bu tezlikni sezilarli oshiradi.

2.3 while (true) va break

Oldingi darsda ataylab cheksiz sikl haqida gaplashgandik. Endi chiqish yo'lini bilamiz. Ba'zan to'xtash shartini sikl boshida emas, o'rtasida tekshirish qulayroq:

const telefonNarxi = 3500000;
let jamgarma = 0;
let oy = 0;

while (true) {
  oy++;
  jamgarma += 400000;

  if (jamgarma >= telefonNarxi) {
    break;
  }
}

console.log(`${oy}-oyda yetadi: ${jamgarma} so'm`);

Konsolda:

9-oyda yetadi: 3600000 so'm

Har oy 400 000 so'm yig'ilyapti. while (true) shartini tekshirishning ma'nosi yo'q — u doim true. Siklni faqat ichidagi break to'xtatadi.

Yana bir misol: 100 dan katta, 7 ga ham, 13 ga ham bo'linadigan birinchi son qaysi?

let son = 100;

while (true) {
  son++;
  if (son % 7 === 0 && son % 13 === 0) {
    break;
  }
}

console.log(son); // 182

Diqqat: while (true) ichida break ga olib boradigan yo'l albatta bo'lsin. Shart hech qachon bajarilmasa — sikl cheksiz aylanadi.

2.4 break faqat eng yaqin siklni to'xtatadi

Sikl ichida sikl bo'lsa, break faqat o'zi turgan siklni to'xtatadi:

for (let qator = 1; qator <= 3; qator++) {
  for (let orin = 1; orin <= 5; orin++) {
    if (orin === 3) {
      break;
    }
    console.log(`${qator}-qator, ${orin}-o'rin`);
  }
}

Konsolda:

1-qator, 1-o'rin
1-qator, 2-o'rin
2-qator, 1-o'rin
2-qator, 2-o'rin
3-qator, 1-o'rin
3-qator, 2-o'rin

break ichki siklni (o'rinlarni) to'xtatdi. Tashqi sikl (qatorlar) esa bemalol davom etdi. Har qatorda faqat 2 ta o'rin chiqdi. Tashqi siklni ham to'xtatish kerak bo'lsa-chi? Buni label'lar bo'limida ko'ramiz.

Tekshirib ko'ring: Konsolda nima chiqadi?

js

let i = 0;
while (i < 10) {
  i++;
  if (i === 3) break;
}
console.log(i);

3. continue — aylanishni o'tkazib yuborish

3.1 13-qavatsiz lift

Ba'zi binolarda 13-qavat bo'lmaydi — liftda 12 dan keyin darhol 14 keladi. Buni continue bilan yozamiz:

for (let qavat = 11; qavat <= 15; qavat++) {
  if (qavat === 13) {
    continue;
  }
  console.log(`${qavat}-qavat`);
}

Konsolda:

11-qavat
12-qavat
14-qavat
15-qavat

continue — "davom et". U tananing qolgan qismini tashlab, darhol keyingi aylanishga o'tadi. Sikl to'xtamaydi.

3.2 for da continue qayerga sakraydi?

for siklida continue dan keyin dastur qadamga (qavat++) o'tadi, keyin shartni tekshiradi:

Qadam baribir bajarildi. Bu for da continue ni xavfsiz qiladi. while da esa boshqacha — hozir ko'ramiz.

3.3 Keraksiz holatlarni oldindan chiqarib tashlash

continue ko'pincha "bu menga kerak emas — keyingisiga" degan filtr sifatida ishlatiladi. Masalan, 1 dan 10 gacha, 3 ga bo'linmaydigan sonlar yig'indisi:

let yigindi = 0;

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

console.log(yigindi); // 37

3, 6 va 9 o'tkazib yuborildi: 1 + 2 + 4 + 5 + 7 + 8 + 10 = 37.

Albatta, buni continue siz ham yozsa bo'ladi: if (i % 3 !== 0) { yigindi += i; }. Qaysi biri yaxshiroq? Tana qisqa bo'lsa — farqi yo'q. Tana uzun bo'lsa, continue qulayroq. U asosiy kodni qo'shimcha { } ichiga kiritmasdan, keraksiz holatni boshidayoq "chiqarib tashlaydi". Bu if / else darsidagi guard clause g'oyasining sikldagi ko'rinishi.

3.4 while dagi continue tuzog'i

while da qadamni o'zingiz yozasiz. continue esa uni ham o'tkazib yuborishi mumkin:

// ❌ ISHGA TUSHIRMANG!
let qavat = 11;

while (qavat <= 15) {
  if (qavat === 13) {
    continue;
  }
  console.log(`${qavat}-qavat`);
  qavat++;
}

qavat 13 ga yetganda continue ishlaydi. Dastur qavat++ gacha yetib bormay, shartga qaytadi. qavat hali ham 13 — yana continue. Shu tarzda sikl cheksiz aylanaveradi. Konsolda 11-qavat, 12-qavat chiqadi, keyin dastur qotib qoladi. (Ctrl + C bilan to'xtating.)

Tuzatish — qadamni continue dan oldin bajarish:

let qavat = 10;

while (qavat < 15) {
  qavat++;
  if (qavat === 13) {
    continue;
  }
  console.log(`${qavat}-qavat`);
}

Konsolda:

11-qavat
12-qavat
14-qavat
15-qavat

Endi qavat++ tananing birinchi qatori. continue qayerda ishlamasin, qiymat allaqachon oshgan bo'ladi. Boshlang'ich qiymat va shart ham bittaga siljidi (10 va < 15) — kuzatuv jadvali chizib tekshirib ko'ring.

Tekshirib ko'ring: break va continue ning farqini bir gap bilan ayting. Quyidagi kod nima chiqaradi?

js

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

4. Label'lar: ichma-ich sikldan birdaniga chiqish

4.1 Muammo

Seyfning ikki xonali kodi bor. Unutib qo'ydik va hamma variantni birma-bir sinab ko'ramiz: birinchi raqam 0–9, ikkinchi raqam 0–9. Kod topilgan zahoti qidiruvni to'xtatish kerak.

Yuqorida ko'rdik: oddiy break faqat ichki siklni to'xtatadi. Tashqi sikl esa keyingi raqamdan davom etib, behuda aylanaveradi.

4.2 Label bilan yechim

Label (yorliq) — siklga beriladigan nom. U sikl oldiga yoziladi va ikki nuqta bilan tugaydi: tashqi:. Keyin break tashqi deb yozsangiz, aynan shu nomli sikl to'xtaydi — ichidagi hamma sikllar bilan birga.

const sirliKod = 37;
let urinish = 0;

tashqi: for (let a = 0; a <= 9; a++) {
  for (let b = 0; b <= 9; b++) {
    urinish++;
    if (a * 10 + b === sirliKod) {
      console.log(`Topildi: ${a}${b}`);
      break tashqi;
    }
  }
}

console.log(`Urinishlar: ${urinish}`);

Konsolda:

Topildi: 37
Urinishlar: 38

a * 10 + b — ikki raqamdan ikki xonali son yasaydi: a = 3, b = 7 bo'lsa — 37. break tashqi ikkala siklni birdaniga to'xtatdi. Dastur tashqi siklning } qavsidan keyingi qatorga o'tdi.

break tashqi o'rniga oddiy break yozsak, tashqi sikl a = 4, 5, ... 9 ni ham tekshirib chiqardi. Jami 100 ta urinish bo'lardi.

Maslahat: Bu misol xavfsizlik haqida ham ko'p narsa aytadi. 2 xonali kodni kompyuter 100 urinishda albatta topadi. 4 xonali PIN — 10 000 urinishda. Shuning uchun banklar 3 marta noto'g'ri kiritilganda kartani bloklaydi. Parollar esa uzun va har xil belgilardan bo'lishi kerak.

Label nomi — oddiy nom, xuddi o'zgaruvchi nomi kabi. tashqi, qidiruv, qatorlar — istalganini tanlash mumkin. Ingliz tilidagi kodlarda ko'pincha outer ("tashqi") uchraydi.

4.3 continue bilan label

continue tashqi — ichki siklni to'xtatib, tashqi siklning keyingi aylanishiga o'tadi.

Kinoteatr xodimi har qatordagi o'rindiqlarni tekshiradi. Qatorda bitta ham singan o'rindiq bo'lsa, qator yopiladi va "tayyor" deb belgilanmaydi. Tasavvur qilaylik, 2-qatorning 3-o'rni singan:

qatorlar: for (let qator = 1; qator <= 3; qator++) {
  for (let orin = 1; orin <= 4; orin++) {
    if (qator === 2 && orin === 3) {
      console.log(`${qator}-qator yopildi`);
      continue qatorlar;
    }
  }
  console.log(`${qator}-qator tayyor`);
}

Konsolda:

1-qator tayyor
2-qator yopildi
3-qator tayyor

2-qatorda singan o'rin topilgach, continue qatorlar ikki ishni bajardi: ichki siklni to'xtatdi va tashqi sikldagi console.log(... tayyor) qatorini o'tkazib yubordi. Dastur darhol 3-qatorga o'tdi.

4.4 Label'dan kamdan-kam foydalaning

Label to'g'ri ishlaydi, lekin real kodda kamdan-kam uchraydi. Ko'p dasturchilar uni umuman ishlatmaydi. Sababi: kod ichida "sakrashlar" ko'paysa, uni o'qish qiyinlashadi.

Muqobil 1 — bayroq (flag) o'zgaruvchi. Mantiqiy o'zgaruvchi "topildi" degan xabarni tashqi siklga yetkazadi:

const sirliKod = 37;
let topildi = false;

for (let a = 0; a <= 9 && !topildi; a++) {
  for (let b = 0; b <= 9; b++) {
    if (a * 10 + b === sirliKod) {
      topildi = true;
      break;
    }
  }
}

console.log(topildi); // true

Ichki break ichki siklni to'xtatadi. Tashqi sikl shartida !topildi bor — u ham to'xtaydi.

Muqobil 2 — funksiya va return. Ichma-ich siklni alohida funksiyaga o'rab, topilgan zahoti return bilan chiqish. Bu eng toza usul, lekin funksiyalarni hali o'rganmadik. return darsida aynan shu usulni ko'rasiz.

Shunday qilib: label'ni tanib olishingiz kerak — boshqalarning kodida uchraydi. O'zingiz esa avval muqobillarni o'ylab ko'ring.

Tekshirib ko'ring: Seyf misolida sirliKod 5 bo'lsa, Urinishlar nechta chiqadi?

5. Ko'p uchraydigan xatolar

5.1 Sikldan tashqarida break yoki continue

const ball = 45;

if (ball < 60) {
  console.log("Imtihondan o'tmadingiz");
  break;
}

SyntaxError: Illegal break statement

Tarjimasi: "Noqonuniy break ko'rsatmasi". break faqat sikl (yoki switch) ichida ishlaydi. if — sikl emas, undan break bilan "chiqib" bo'lmaydi. if ning qolgan qismini bajarmaslik kerak bo'lsa, else ishlating.

continue uchun xabar yanada aniqroq:

SyntaxError: Illegal continue statement: no surrounding iteration statement

"Noqonuniy continue: atrofda sikl yo'q". Iteration statement — sikl degani. Bu ikki xato ham kod ishga tushishidan oldin chiqadi — bitta qator ham bajarilmaydi.

5.2 Label nomida xato

tashqi: for (let a = 0; a <= 9; a++) {
  for (let b = 0; b <= 9; b++) {
    if (a + b === 5) break tashqii;
  }
}

SyntaxError: Undefined label 'tashqii'

"tashqii nomli label aniqlanmagan". Label nomi harfma-harf mos kelishi kerak. Label faqat siklning o'z ichidan ishlaydi: boshqa sikl nomi bilan chiqib bo'lmaydi.

5.3 switch ichidagi break sikldan chiqarmaydi

Bu tuzoq ko'pchilikni chalg'itadi. Sikl ichida switch bor:

for (let i = 1; i <= 3; i++) {
  switch (i) {
    case 2:
      console.log("ikki — to'xtaymiz");
      break;
    default:
      console.log(i);
  }
}

Konsolda:

1
ikki — to'xtaymiz
3

"To'xtaymiz" deb yozdik, lekin sikl davom etdi va 3 ham chiqdi. Sababi: switch ichidagi break faqat switch dan chiqaradi, sikldan emas. break doim eng yaqin sikl yoki switch ni tugatadi. Siklni to'xtatish kerak bo'lsa — siklga label bering va break nom yozing yoki switch o'rniga if ishlating.

5.4 while da continue va qadam

while dagi tuzoqda ko'rdik: continue qadamni (i++) o'tkazib yuborsa — cheksiz sikl. Qoida: while da qadamni tananing boshiga qo'ying yoki for ishlating.

5.5 break dan keyingi kod

for (let i = 1; i <= 3; i++) {
  console.log(i);
  break;
  console.log("Bu hech qachon chiqmaydi");
}

Konsolda:

1

break dan keyin, xuddi shu blokdagi kod hech qachon bajarilmaydi. JavaScript xato bermaydi, VS Code esa bunday kodni xiraroq rangda ko'rsatadi. Xira kodni ko'rsangiz — uning oldida break, continue yoki shunga o'xshash "chiqish" bormi, tekshiring.

6. Mashqlar

1-mashq (oson): Toq sonlar

continue yordamida 1 dan 15 gacha faqat toq sonlarni chiqaring. Juft sonni i % 2 === 0 bilan aniqlang (qoldiq operatori).

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

1
3
5
7
9
11
13
15

2-mashq (o'rta): Birinchi bo'sh joy

Foydalanuvchi to'liq ismini kiritdi: "Jasur Karimov". Birinchi bo'sh joygacha bo'lgan qismni (ismni) ajratib oling. Sikl bo'sh joyni topgan zahoti break bilan to'xtasin.

Ishora: let ism = ""; dan boshlang. Har belgini tekshiring: bo'sh joy (" ") bo'lsa — break, aks holda ism += belgi.

const toliqIsm = "Jasur Karimov";
let ism = "";

for (let i = 0; i < toliqIsm.length; i++) {
  if (toliqIsm[i] === " ") {
    break;
  }
  ism += toliqIsm[i];
}

console.log(ism); // Jasur

3-mashq (qiyin): 100 dan keyingi birinchi tub son

Tub son — faqat 1 ga va o'ziga qoldiqsiz bo'linadigan son (2, 3, 5, 7, 11...). 100 dan katta birinchi tub sonni toping.

Ishora:

• Tashqi sikl: for (let son = 101; ; son++) — shart yo'q, siklni break to'xtatadi.
• Ichki sikl: bo'luvchini (bol deb nomlang — nomda apostrof bo'lmaydi) 2 dan son - 1 gacha aylantiring. son % bol === 0 bo'lsa — son tub emas, ichki sikldan break.
• let tub = true; bayrog'idan foydalaning. Ichki sikldan keyin tub hali ham true bo'lsa — javob topildi.

for (let son = 101; ; son++) {
  let tub = true;

  for (let bol = 2; bol < son; bol++) {
    if (son % bol === 0) {
      tub = false;
      break;
    }
  }

  if (tub) {
    console.log(son); // 101
    break;
  }
}

7. Real ishda

• Qidiruv: ro'yxatdan kerakli foydalanuvchi, mahsulot yoki buyurtmani topgach, qidiruv to'xtatiladi — break.
• Ma'lumotni tozalash: bo'sh qatorlar, noto'g'ri yozuvlar continue bilan o'tkazib yuboriladi, qolganlari ishlanadi.
• Server va botlar: while (true) — "abadiy" ishlaydigan sikl. U to'xtash signali kelganda break bilan tugaydi.
• Label'lar real loyihalarda kam uchraydi. Ko'pincha kod funksiyaga ajratilib, return ishlatiladi.

Keyinroq massivlar bilan ishlaganda ko'rasiz: forEach kabi ba'zi usullarda break umuman ishlamaydi. Shuning uchun erta to'xtash kerak bo'lsa, oddiy sikl tanlanadi. Intervyuda "break va continue farqi nima?" — boshlang'ich darajadagi klassik savol.

Xulosa

• break — siklni darhol va butunlay to'xtatadi. Dastur sikldan keyingi qatorga o'tadi.
• continue — joriy aylanishning qolgan qismini tashlab, keyingisiga o'tadi.
• Ikkalasi ham faqat eng yaqin siklga ta'sir qiladi. switch ichidagi break esa faqat switch dan chiqaradi.
• while da continue qadamni o'tkazib yuborsa — cheksiz sikl. Qadamni tananing boshiga qo'ying.
• Label (tashqi:) bilan ichma-ich sikldan birdaniga chiqiladi. Lekin undan kamdan-kam foydalaning.
• Tashqarida ishlatilsa — SyntaxError: Illegal break statement.

Oldingi dars: while va do...while.

Keyingi dars: for...of va for...in: farqi va tuzoqlari — indeks bilan ovora bo'lmasdan satr belgilari va obyekt kalitlari bo'ylab yurish.