JavaScript for sikli: kodni kerakli marta takrorlash

Qisqacha: for sikli bir xil kodni kerakli marta takrorlaydi. U uch qismdan iborat: boshlanish (let i = 1), shart (i <= 5) va qadam (i++). Masalan, for (let i = 1; i <= 5; i++) { console.log(i); } konsolga 1 dan 5 gacha sonlarni chiqaradi. Necha marta takrorlash oldindan ma'lum bo'lsa, for — eng qulay tanlov.

Bu darsda

• for siklini yoza olasiz va uning uch qismi nima qilishini tushuntira olasiz.
• Siklni qog'ozda qadamma-qadam kuzatib (jadval bilan), natijani oldindan ayta olasiz.
• Teskari sanash, 2 qadamli sanash va 1 dan n gacha yig'indini hisoblay olasiz.
• Ichma-ich sikl bilan ko'paytirish jadvalini chiqara olasiz.
• Off-by-one xatosini va cheksiz siklni taniysiz, cheksiz siklni to'xtata olasiz.

Oldin bilishingiz kerak: if / else, Arifmetik va tayinlash operatorlari (++, +=), Taqqoslash operatorlari, Template literals.

1. Nega bu kerak?

Tasavvur qiling: siz bank filialida elektron navbat tizimini yozyapsiz. Ertalab ekranga birinchi 5 ta chipta raqami chiqishi kerak:

console.log("Chipta: 1");
console.log("Chipta: 2");
console.log("Chipta: 3");
console.log("Chipta: 4");
console.log("Chipta: 5");

5 ta chipta uchun bu chidasa bo'ladi. Lekin 300 ta chipta kerak bo'lsa-chi? 300 qator yozasizmi? Ertaga "Chipta" so'zini "Navbat" ga almashtirishsa, 300 joyni tuzatasizmi?

Bu qatorlarga diqqat bilan qarang. Hammasi bir xil, faqat raqam bittaga oshib boryapti. Kompyuter aynan shunday ishni yaxshi bajaradi: "shu ishni 300 marta qil, har safar raqamni bittaga oshir".

Sikl (loop) — bir xil kodni qayta-qayta bajaradigan tuzilma. Hayotdan o'xshatish: stadionda 5 aylana yugurish. Har aylanada bir xil ish qilasiz (yugurasiz), faqat aylana soni o'zgaradi: 1, 2, 3... Beshinchidan keyin to'xtaysiz.

Siklning har bir aylanishi iteratsiya (iteration) deb ataladi. Bu darsda "aylanish" so'zini ishlatamiz — ma'nosi bir xil.

2. Birinchi for sikli

2.1 5 ta chipta — 3 qatorda

Yuqoridagi 5 qatorni for bilan yozamiz:

for (let i = 1; i <= 5; i++) {
  console.log(`Chipta: ${i}`);
}

Konsolda:

Chipta: 1
Chipta: 2
Chipta: 3
Chipta: 4
Chipta: 5

Endi 300 ta chipta kerak bo'lsa, faqat 5 ni 300 ga almashtirasiz. "Chipta" so'zini o'zgartirish kerak bo'lsa — bitta joyni tuzatasiz.

O'zingiz sinab ko'ring: sikl.js fayl yarating, kodni joylang va terminalda node sikl.js deb ishga tushiring. Keyin 5 ni 10 ga o'zgartirib, yana ishga tushiring.

2.2 for ning tuzilishi

Qavs ichida uch qism bor. Ular nuqta-vergul ; bilan ajratiladi:

for (boshlanish; shart; qadam) {
  // tana: har aylanishda bajariladigan kod
}

Bizning misolda:

i — hisoblagich (counter). U siklning nechanchi marta aylanayotganini eslab turadi. Nomi i bo'lishi shart emas, lekin dasturchilar odatda shunday yozishadi (inglizcha "index" yoki "iteration" so'zidan).

Tartib bunday:

1. let i = 1 — bir marta bajariladi.
2. i <= 5 tekshiriladi. false bo'lsa — sikl tugaydi.
3. true bo'lsa — tana bajariladi.
4. i++ — hisoblagich bittaga oshadi.
5. Yana 2-qadamga qaytiladi.

Maslahat: Siklni "Shart to'g'ri ekan — tanani bajar, qadam qo'y, yana tekshir" deb o'qing. Shart yolg'on bo'lgan zahoti sikl tugaydi.

2.3 Siklni qog'ozda kuzatish

Sikl nima chiqarishini bilishning eng ishonchli yo'li — uni qog'ozda qadamma-qadam kuzatish. Dasturchilar buni kuzatuv jadvali (trace table) deyishadi.

Kichikroq siklni olamiz:

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

Konsolda:

1
2
3

Endi uni jadvalda kuzatamiz:

E'tibor bering: shart 4 marta tekshirildi, tana esa 3 marta bajarildi. Oxirgi tekshiruv false beradi — siklni aynan shu to'xtatadi.

Sikl sizni chalkashtirsa, shunday jadval chizing. Tajribali dasturchilar ham murakkab siklni shu usulda tekshiradi.

Tekshirib ko'ring: for (let i = 0; i < 4; i++) sikli necha marta aylanadi? i qaysi qiymatlarni oladi?

3. Sanashning turli shakllari

3.1 Teskari sanash

Yangi yil kechasi: 5 dan 1 gacha sanaymiz. Hisoblagich kamayib borishi kerak — i--:

for (let i = 5; i >= 1; i--) {
  console.log(i);
}
console.log("Yangi yil muborak!");

Konsolda:

5
4
3
2
1
Yangi yil muborak!

Uch qism ham o'zgardi. Boshlanish — katta son (5). Shart — i >= 1 ("hali 1 dan kichik bo'lmaguncha"). Qadam — i-- (bittaga kamaytirish).

console.log("Yangi yil muborak!") siklning { } qavslaridan tashqarida turibdi. Shuning uchun u bir marta, sikl tugagandan keyin bajariladi.

3.2 2 qadamli sanash

Qadam har doim 1 bo'lishi shart emas. i += 2 — hisoblagichni 2 ga oshiradi. Masalan, juft sonlar:

for (let i = 2; i <= 10; i += 2) {
  console.log(i);
}

Konsolda:

2
4
6
8
10

Hayotiy misol: taksi haydovchisi har 5 km da mashinani tekshiradi. Yo'l 20 km:

for (let km = 5; km <= 20; km += 5) {
  console.log(`${km} km: shinalarni tekshirish`);
}

Konsolda:

5 km: shinalarni tekshirish
10 km: shinalarni tekshirish
15 km: shinalarni tekshirish
20 km: shinalarni tekshirish

Bu yerda hisoblagich nomi km. Ma'noli nom kodni o'qishni osonlashtiradi.

3.3 Chegara — o'zgaruvchida

Sikl necha marta aylanishi o'zgaruvchiga bog'liq bo'lishi mumkin:

const mehmonlar = 4;

for (let i = 1; i <= mehmonlar; i++) {
  console.log(`${i}-mehmonga choy quyildi`);
}

Konsolda:

1-mehmonga choy quyildi
2-mehmonga choy quyildi
3-mehmonga choy quyildi
4-mehmonga choy quyildi

Ertaga mehmonlar 12 bo'lsa — sikl 12 marta aylanadi. Kodning qolgan qismi o'zgarmaydi.

Tekshirib ko'ring: for (let i = 20; i > 0; i -= 5) sikli nimalarni chiqaradi (tanada console.log(i))?

4. Sikl ichida hisoblash

4.1 1 dan n gacha yig'indi

Sikl faqat chiqarish uchun emas. U hisoblash uchun ham kerak. Masalan, 1 dan 5 gacha sonlar yig'indisi:

let yigindi = 0;

for (let i = 1; i <= 5; i++) {
  yigindi += i;
}

console.log(yigindi); // 15

yigindi — yig'uvchi o'zgaruvchi. Uni sikldan oldin 0 bilan boshlaymiz. Har aylanishda unga i ni qo'shamiz. Qiymati o'zgarib turadi, shuning uchun const emas, let.

Kuzatuv jadvali:

Xuddi shunday, bir haftalik savdoni hisoblash, 12 oylik to'lovlarni qo'shish — hammasi shu naqsh bilan yoziladi.

Maslahat: 1 dan n gacha yig'indining tayyor formulasi ham bor: n * (n + 1) / 2. n = 5 uchun 5 * 6 / 2 = 15. Formula bilan siklingiz to'g'ri ishlayotganini tekshirish qulay.

Ko'paytma ham xuddi shu naqsh bilan yig'iladi, faqat boshlang'ich qiymat 0 emas, 1. BigInt darsida va'da qilingan 25! (1 dan 25 gacha sonlar ko'paytmasi) — mana u:

let faktorial = 1n;

for (let i = 1n; i <= 25n; i++) {
  faktorial *= i;
}

console.log(faktorial); // 15511210043330985984000000n

Hisoblagich ham BigInt (1n), chunki BigInt'ni oddiy son bilan aralashtirib bo'lmaydi. i++ BigInt bilan ham ishlaydi. Oddiy son bilan hisoblasangiz, natija 1.5511210043330986e+25 bo'lib, oxirgi raqamlari yo'qolardi.

4.2 Sikl ichida if

Sikl tanasida if ham ishlatsa bo'ladi. Do'konda har 3-xaridor sovg'a oladi:

for (let xaridor = 1; xaridor <= 7; xaridor++) {
  if (xaridor % 3 === 0) {
    console.log(`${xaridor}-xaridor: sovg'a!`);
  } else {
    console.log(`${xaridor}-xaridor`);
  }
}

Konsolda:

1-xaridor
2-xaridor
3-xaridor: sovg'a!
4-xaridor
5-xaridor
6-xaridor: sovg'a!
7-xaridor

xaridor % 3 === 0 — "3 ga qoldiqsiz bo'linadimi?" (% operatori). 3 va 6 uchun true.

4.3 Satr belgilari bo'ylab

String asoslari darsida ko'rgandik: satr belgilarining o'z raqami (indeksi) bor, u 0 dan boshlanadi. ism[0] — birinchi harf, ism.length — belgilar soni.

Demak, i ni 0 dan ism.length - 1 gacha aylantirsak, hamma harflarni birma-bir olamiz:

const ism = "Malika";

for (let i = 0; i < ism.length; i++) {
  console.log(`${i}: ${ism[i]}`);
}

Konsolda:

0: M
1: a
2: l
3: i
4: k
5: a

Shartda i < ism.length yozildi, <= emas. ism.length — 6, oxirgi indeks esa 5. Bu farq juda muhim — xatolar bo'limida qaytamiz.

Endi o'zingiz to'ldiring. Quyidagi kod "Toshkent" so'zidagi kichik "t" harflarini sanaydi:

const shahar = "Toshkent";
let soni = 0;

for (let i = 0; i < shahar.length; i++) {
  if (shahar[i] === "t") {
    soni++;
  }
}
console.log(soni);

Konsolga nima chiqadi? Javob: . (Maslahat: katta T va kichik t — ikki xil belgi.)

Tekshirib ko'ring: let yigindi = 0; qatorini sikl ichiga ko'chirsak nima bo'ladi?

5. Ichma-ich sikllar

5.1 Sikl ichida sikl

Sikl tanasida yana bitta sikl bo'lishi mumkin. Bu ichma-ich sikl (nested loop). Qoidasi: tashqi siklning har bir aylanishida ichki sikl boshidan oxirigacha to'liq aylanadi.

Hayotdan o'xshatish: devordagi soat. Soat mili bitta belgiga siljiguncha daqiqa mili 60 qadam yurib, to'liq aylanib chiqadi. Soat mili — tashqi sikl, daqiqa mili — ichki.

Maktabda 2 ta sinf, har birida 3 ta dars bor:

for (let sinf = 1; sinf <= 2; sinf++) {
  for (let dars = 1; dars <= 3; dars++) {
    console.log(`${sinf}-sinf, ${dars}-dars`);
  }
}

Konsolda:

1-sinf, 1-dars
1-sinf, 2-dars
1-sinf, 3-dars
2-sinf, 1-dars
2-sinf, 2-dars
2-sinf, 3-dars

Tashqi sikl 2 marta, ichki sikl har safar 3 martadan aylandi. Jami: 2 × 3 = 6 qator.

5.2 Ko'paytirish jadvali

Ichma-ich siklning klassik misoli — ko'paytirish jadvali. Har qatorni avval bitta satrga yig'amiz, keyin chiqaramiz:

for (let i = 1; i <= 4; i++) {
  let qator = "";
  for (let j = 1; j <= 4; j++) {
    qator += String(i * j).padStart(4);
  }
  console.log(qator);
}

Konsolda:

   1   2   3   4
   2   4   6   8
   3   6   9  12
   4   8  12  16

Bu yerda nima bo'ldi:

• Tashqi sikl (i) — qatorlar. Har qator boshida qator bo'sh satr bo'ladi.
• Ichki sikl (j) — ustunlar. Har bir ko'paytmani qator oxiriga qo'shadi.
• String(i * j).padStart(4) — sonni satrga aylantirib, chapdan bo'sh joy bilan 4 belgiga to'ldiradi. Shunda ustunlar tekis turadi. String() — turlarni o'zgartirish darsidan, padStart — satr metodlari darsidan.
• Ichki sikl tugagach, tayyor qator konsolga chiqadi.

Ichki sikl hisoblagichi odatda j deb nomlanadi (i dan keyingi harf).

Diqqat: Ichma-ich sikllar tez "semiradi". Tashqi 1 000 marta, ichki 1 000 marta aylansa — tana 1 000 000 marta bajariladi. Uchinchi sikl qo'shilsa — milliard. Ichma-ich siklni faqat haqiqatan kerak bo'lganda ishlating.

Tekshirib ko'ring: Quyidagi kod nechta yulduzcha chiqaradi?

js

for (let i = 1; i <= 3; i++) {
  for (let j = 1; j <= i; j++) {
    console.log("*");
  }
}

6. let i faqat sikl ichida yashaydi

for (let i = ...) da yaratilgan i faqat sikl ichida mavjud. Sikl tugagach, u yo'qoladi:

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

Konsolda avval 1, 2, 3, keyin qizil xato chiqadi:

ReferenceError: i is not defined

"i aniqlanmagan". Bu yaxshi narsa: keyingi siklda yana i nomini bemalol ishlatasiz, ular bir-biriga xalaqit bermaydi.

Yana bir detal: JavaScript har aylanish uchun i ning yangi nusxasini yaratadi. Hozir buning farqini sezmaysiz. Keyinroq, "kechiktirib bajariladigan" kodda bu juda muhim bo'ladi. Buni closure tuzoqlari darsida batafsil ko'ramiz.

Maslahat: Hisoblagichni doim let bilan e'lon qiling. var bilan ham ishlaydi, lekin var sikldan keyin ham "osilib" qoladi — var darsida nega bu yomon ekanini ko'rgansiz.

7. Kamroq uchraydigan shakllar

7.1 Ikki hisoblagich bir vaqtda

Boshlanish va qadam qismida bir nechta ifodani vergul bilan yozish mumkin (vergul operatori). Masalan, ikki kishi yo'lning ikki uchidan bir-biriga qarab yuryapti:

for (let ali = 0, vali = 10; ali < vali; ali++, vali--) {
  console.log(`Ali: ${ali} km, Vali: ${vali} km`);
}

Konsolda:

Ali: 0 km, Vali: 10 km
Ali: 1 km, Vali: 9 km
Ali: 2 km, Vali: 8 km
Ali: 3 km, Vali: 7 km
Ali: 4 km, Vali: 6 km

Qadamda ikkala hisoblagich birga o'zgaradi: ali oshadi, vali kamayadi. Keyingi qadamda ikkalasi 5 km belgisida uchrashadi: 5 < 5 — false, sikl tugaydi. Bunday sikl kam uchraydi, lekin boshqalarning kodida ko'rsangiz, taniysiz.

7.2 Qismlarni tashlab ketish

Uch qismning istalganini bo'sh qoldirish mumkin. Faqat nuqta-vergullar qoladi:

let i = 1;

for (; i <= 3; ) {
  console.log(i);
  i++;
}

Konsolda:

1
2
3

Bu ishlaydi, lekin o'qish qiyin. Bunday holatlar uchun keyingi darsdagi while sikli ancha mos keladi.

Shart qismi ham bo'sh bo'lsa (for (;;)), JavaScript uni doim true deb hisoblaydi. Bu — cheksiz sikl. Keling, u haqda gaplashamiz.

8. Cheksiz sikl: xavf va undan chiqish

Cheksiz sikl (infinite loop) — sharti hech qachon false bo'lmaydigan sikl. U to'xtamay aylanaveradi. Kompyuter qotib qolgandek bo'ladi.

Eng ko'p uchraydigan sabab — qadam noto'g'ri tomonga ketadi:

// ❌ ISHGA TUSHIRMANG!
for (let i = 1; i <= 5; i--) {
  console.log(i);
}

i 1 dan boshlanib, i-- bilan kamayib boradi: 1, 0, -1, -2... U hech qachon 5 dan katta bo'lmaydi. Demak, i <= 5 doim true.

Yana bir yashirin sabab — kasr qadam. Number darsida ko'rgandik: 0.1 + 0.2 roppa-rosa 0.3 emas.

// ❌ ISHGA TUSHIRMANG!
for (let x = 0; x !== 1; x += 0.1) {
  console.log(x);
}

x qiymati 0.1, 0.2, 0.30000000000000004... bo'lib boradi. U 1 ga roppa-rosa teng bo'lmaydi va 1 ning yonidan "o'tib ketadi". Shart !== bo'lgani uchun sikl to'xtamaydi. Yechim: !== o'rniga < yoki <= ishlating.

Cheksiz siklni qanday to'xtatish mumkin?

• Terminalda (Node): Ctrl + C ni bosing. Bu dasturni darhol to'xtatadi.
• Brauzerda: sahifa qotib qoladi. Shu yorliqni (tab) yoping. Ba'zan brauzer o'zi "Page Unresponsive" ("sahifa javob bermayapti") degan oyna chiqaradi — undagi "Exit page" ("sahifadan chiqish") tugmasini bosing.

Diqqat: Ichida console.log bo'lgan cheksiz sikl konsolni juda tez to'ldiradi va kompyuterni sekinlashtiradi. Qo'rqmang — hech narsa buzilmaydi, faqat dasturni to'xtating. Keyin shartni va qadamni tekshiring.

Har sikl yozganingizda o'zingizga bitta savol bering: "Bu sikl qachon to'xtaydi?" Javob aniq bo'lmasa — kodni ishga tushirmang.

9. Ko'p uchraydigan xatolar

9.1 Bittaga adashish (off-by-one)

Eng mashhur sikl xatosi — bir marta ko'p yoki bir marta kam aylanish. Inglizcha nomi — off-by-one ("bittaga siljish").

Ismning hamma harfini chiqarmoqchimiz, lekin <= yozib qo'ydik:

const ism = "Ali";

for (let i = 0; i <= ism.length; i++) {
  console.log(ism[i]);
}

Konsolda:

A
l
i
undefined

Xato bermadi, lekin oxirida ortiqcha undefined chiqdi. ism.length — 3, indekslar esa 0, 1, 2. i = 3 bo'lganda ism[3] — bunday belgi yo'q, natija undefined.

Qanday oldini olish mumkin:

• 0 dan boshlasangiz — i < n yozing (n marta aylanadi).
• 1 dan boshlasangiz — i <= n yozing (bu ham n marta).
• Shubha bo'lsa — kichik son bilan kuzatuv jadvali chizing.

Hayotdan o'xshatish: 10 metrli panjara, har 1 metrda ustun. Nechta ustun kerak? 10 emas, 11 ta! Bunday "bittaga adashish" dasturlashda ham, hayotda ham tez-tez uchraydi.

9.2 Nuqta-vergul o'rniga vergul

for (let i = 0, i < 5, i++) {
  console.log(i);
}

SyntaxError: Identifier 'i' has already been declared

Tarjimasi: "i nomi allaqachon e'lon qilingan". G'alati, to'g'rimi? Siz faqat vergulni adashtirdingiz. Lekin JavaScript let i = 0, i < 5 ni "ikkita o'zgaruvchi e'lon qilish" deb o'qidi: birinchisi i, ikkinchisi yana i. Qoida: for qavsida qismlar faqat nuqta-vergul ; bilan ajratiladi.

9.3 Qavsdan keyin nuqta-vergul

for (let i = 1; i <= 3; i++); {
  console.log("Salom");
}

Konsolda:

Salom

"Salom" 3 marta emas, 1 marta chiqdi! Qavsdan keyingi ; — "bo'sh tana". Sikl hech narsa qilmay 3 marta aylandi. { ... } bloki esa sikldan keyin oddiy kod sifatida bir marta bajarildi. JavaScript bu yerda xato ham bermaydi, shuning uchun uni topish qiyin. for (...) va { orasida hech narsa bo'lmasin.

9.4 Hisoblagichni const bilan e'lon qilish

for (const i = 0; i < 3; i++) {
  console.log(i);
}

Konsolda avval 0 chiqadi, keyin:

TypeError: Assignment to constant variable.

"O'zgarmas o'zgaruvchiga qiymat berish". Birinchi aylanish ishladi, lekin i++ qadamida const ni o'zgartirishga urinildi. Hisoblagich har doim o'zgaradi, shuning uchun — let.

10. Mashqlar

1-mashq (oson): Lift

Lift 1-qavatdan 9-qavatgacha ko'tariladi. Har qavatda 3-qavat ko'rinishidagi yozuv chiqsin, eng oxirida esa Yetib keldik! yozuvi.

Keyin siklni teskari aylantiring: lift 9 dan 1 gacha tushsin.

for (let qavat = 1; qavat <= 9; qavat++) {
  console.log(`${qavat}-qavat`);
}
console.log("Yetib keldik!");

1-qavat
2-qavat
3-qavat
4-qavat
5-qavat
6-qavat
7-qavat
8-qavat
9-qavat
Yetib keldik!

for (let qavat = 9; qavat >= 1; qavat--) {
  console.log(`${qavat}-qavat`);
}

2-mashq (o'rta): Juft sonlar yig'indisi

1 dan 100 gacha bo'lgan juft sonlar yig'indisini hisoblang va chiqaring. Ikki usulda yozing:

1. Sikl 1 dan 100 gacha aylansin, ichida if va % bilan juftlikni tekshiring.
2. Sikl faqat juft sonlarni aylansin: 2 dan boshlanib, i += 2 qadam bilan.

Ikkala usulda natija bir xil chiqishi kerak.

let yigindi = 0;

for (let i = 1; i <= 100; i++) {
  if (i % 2 === 0) {
    yigindi += i;
  }
}

console.log(yigindi); // 2550

let yigindi = 0;

for (let i = 2; i <= 100; i += 2) {
  yigindi += i;
}

console.log(yigindi); // 2550

3-mashq (qiyin): Yulduzcha zinapoya

Ichma-ich sikl bilan quyidagi shaklni chiqaring:

*
**
***
****
*****

Ishora: tashqi sikl (i, 1 dan 5 gacha) — qatorlar. Har qator boshida let qator = ""; yozing. Ichki sikl j ni 1 dan i gacha aylantirib, har safar qator += "*" qilsin. Ichki sikldan keyin console.log(qator).

Bonus: "*".repeat(i) (satr metodlari) bilan ichki siklsiz yozib ko'ring.

for (let i = 1; i <= 5; i++) {
  let qator = "";
  for (let j = 1; j <= i; j++) {
    qator += "*";
  }
  console.log(qator);
}

*
**
***
****
*****

for (let i = 1; i <= 5; i++) {
  console.log("*".repeat(i));
}

11. Real ishda

for sikli dasturchining kundalik asbobi:

• Onlayn do'kon: savatdagi har bir mahsulot narxini qo'shib, jami summani hisoblash.
• Hisobotlar: 12 oy bo'yicha savdoni birma-bir ko'rib chiqish.
• Jadvallar va o'yinlar: shaxmat taxtasi, kinoteatr o'rindiqlari (qator × o'rin) — ichma-ich sikl.
• Ma'lumot tekshirish: parolning har bir belgisini tekshirish.

Keyinroq massivlar bilan ishlaganda for yanada ko'p kerak bo'ladi.

Intervyularda "1 dan n gacha yig'indi", "yulduzcha piramida", "FizzBuzz" kabi sikl masalalari boshlang'ich dasturchiga tez-tez beriladi. Off-by-one xatosini ko'rsatib bera olish ham yaxshi baho oladi.

Xulosa

• for (boshlanish; shart; qadam) { tana } — necha marta aylanishi ma'lum bo'lganda eng qulay sikl.
• Tartib: boshlanish bir marta → shart → tana → qadam → yana shart. Shart false bo'lsa, sikl tugaydi.
• Sikl nima qilishini bilish uchun kuzatuv jadvali chizing.
• Yig'uvchi o'zgaruvchi (let yigindi = 0) sikldan oldin e'lon qilinadi.
• Ichma-ich siklda ichki sikl tashqining har aylanishida to'liq aylanadi.
• 0 dan boshlasangiz i < n, 1 dan boshlasangiz i <= n. Har siklda so'rang: "Bu qachon to'xtaydi?"

Oldingi dars: switch va uning muqobillari.

Keyingi dars: while va do...while — necha marta aylanishi oldindan noma'lum bo'lgan sikllar.