Sikllar — for, while, do-while, for...of, for...in
Muammodan boshlaylik
100 ta foydalanuvchiga xabar yuborish kerak. Yoki massivdagi barcha mahsulot narxini 10% oshirish kerak. Yoki foydalanuvchi to'g'ri parol kiritmaguncha so'rab turish kerak.
Bularni shartsiz yozish mumkin — lekin 100 marta bir xil kod yozish mantiqsiz. Sikllar — bir xil amalni qayta-qayta bajarish uchun.
for — eng ko'p ishlatiladigan sikl
for sikli uchta qismdan iborat: boshlang'ich qiymat, shart, har iteratsiyadan keyin bajariladigan amal.
for (let i = 0; i < 5; i++) {
console.log(i); // 0, 1, 2, 3, 4
}
Uchta qism:
let i = 0— sikl boshlanishida bir marta bajariladii < 5— har iteratsiyadan oldin tekshiriladi;falsebo'lsa sikl to'xtaydii++— har iteratsiyadan keyin bajariladi
Massiv bilan ishlash
const mevalar = ["olma", "nok", "uzum"];
for (let i = 0; i < mevalar.length; i++) {
console.log(mevalar[i]); // "olma", "nok", "uzum"
}
Teskari sikl
for (let i = 4; i >= 0; i--) {
console.log(i); // 4, 3, 2, 1, 0
}
Hayotiy o'xshatma
Tasavvur qiling: zavod konveyeri. Har bir mahsulot lentadan o'tadi — tekshiriladi, etiketka yopishtiriladi, qutiga solinadi. Bir xil amal, har bir mahsulot uchun. Sikl — dasturlashdagi konveyer.
while — shart bajarilguncha
while — shart true bo'lgan vaqtda ishlaydi. Necha marta ishlashini oldindan bilmasangiz ishlatiladi.
let son = 1;
while (son < 100) {
son *= 2; // ← har safar ikki barobarga oshadi
}
console.log(son); // 128 — 100 dan katta bo'lgan birinchi 2 ning darajasi
for bilan ham yozish mumkin edi — lekin while bu holda tabiiyroq: "100 dan katta bo'lguncha ikki barobar oshir".
Foydalanuvchi inputi
let javob = "";
while (javob !== "ha" && javob !== "yo'q") {
javob = prompt("Davom etasizmi? (ha/yo'q)");
}
Foydalanuvchi to'g'ri javob bermaguncha so'raydi. Necha marta so'rashini oldindan bilmaymiz — while mos.
Nima uchun shunday?
for vs while — qachon qaysi?
for — iteratsiya soni ma'lum bo'lganda (massiv, raqam oralig'i).
while — shart qachon false bo'lishini oldindan bilmasangiz.
// for mos — 10 marta aniq
for (let i = 0; i < 10; i++) { ... }
// while mos — qachon to'xtashini bilmaymiz
while (!isConnected) {
tryConnect();
}
Cheksiz sikl xavfi
while da shart hech qachon false bo'lmasa — dastur muzlab qoladi:
let i = 0;
while (i < 10) {
console.log(i);
// i++ unutildi! — cheksiz sikl
}
for da bu kamroq uchraydi — uchta qism ko'rinib turadi.
do...while — kamida bir marta
do...while — avval bajaradi, keyin tekshiradi. Kamida bir marta bajarilishi kafolatlanadi.
let son;
do {
son = Math.floor(Math.random() * 10); // 0-9 orasida tasodifiy son
} while (son !== 5);
console.log("5 chiqdi!");
Amalda kamdan-kam ishlatiladi — lekin "kamida bir marta bajar, keyin tekshir" mantiqida qulay.
for...of — massiv va iterable lar uchun
for...of — massiv, string, Set, Map kabi iterable ob'ektlar uchun. Indeks kerak bo'lmasa — for dan aniqroq.
const mevalar = ["olma", "nok", "uzum"];
for (const meva of mevalar) {
console.log(meva); // "olma", "nok", "uzum"
}
String bilan:
for (const harf of "salom") {
console.log(harf); // "s", "a", "l", "o", "m"
}
Indeks ham kerak bo'lsa — entries():
for (const [i, meva] of mevalar.entries()) {
console.log(i, meva); // 0 "olma", 1 "nok", 2 "uzum"
}
for...in — ob'ekt kalitlari uchun
for...in — ob'ektning barcha kalitlarini (key) aylanib chiqadi.
const odam = { ism: "Ali", yosh: 25, shahar: "Toshkent" };
for (const kalit in odam) {
console.log(kalit, odam[kalit]);
// "ism" "Ali"
// "yosh" 25
// "shahar" "Toshkent"
}
Nima uchun for...in massiv uchun ishlatilmaydi?
const arr = [10, 20, 30];
for (const i in arr) {
console.log(i); // "0", "1", "2" — string indekslar!
}
for...in indekslarni string sifatida qaytaradi. Bundan tashqari, prototip zanjiridan meros olgan xususiyatlarni ham ko'rsatishi mumkin. Massiv uchun for...of yoki forEach ishlatiladi.
break va continue
break — sikldan chiqish
const sonlar = [1, 3, 7, 2, 9, 4];
for (const son of sonlar) {
if (son % 2 === 0) {
console.log("Birinchi juft son:", son); // "Birinchi juft son: 2"
break; // ← topildi, sikldan chiqamiz
}
}
continue — bu iteratsiyani o'tkazib yuborish
for (let i = 0; i < 10; i++) {
if (i % 2 === 0) continue; // ← juft sonlarni o'tkazib yubor
console.log(i); // 1, 3, 5, 7, 9
}
Label — ichki sikldan tashqi siklni boshqarish
Ichma-ich sikllarda break faqat eng ichki sikldan chiqadi. Tashqi sikldan chiqish uchun label ishlatiladi:
outer: for (let i = 0; i < 3; i++) {
for (let j = 0; j < 3; j++) {
if (i === 1 && j === 1) break outer; // ← tashqi sikldan chiqadi
console.log(i, j);
}
}
// 0 0, 0 1, 0 2, 1 0 — keyin to'xtaydi
Label amalda kamdan-kam ishlatiladi — ko'pincha funksiyaga ajratish yaxshiroq.
Tez-tez uchraydigan xatolar
for...in ni massiv uchun ishlatish:
const arr = [10, 20, 30];
for (const i in arr) {
console.log(arr[i] + 1); // ishlaydi, lekin i string — xavfli
}
// ✅ to'g'ri:
for (const val of arr) {
console.log(val + 1);
}
const o'rniga let ishlatish kerak bo'lgan holat:
for (const i = 0; i < 5; i++) { } // ❌ const o'zgartirib bo'lmaydi!
for (let i = 0; i < 5; i++) { } // ✅
for (const item of arr) { } // ✅ const to'g'ri — har iteratsiyada yangi o'zgaruvchi
Cheksiz sikl:
let i = 10;
while (i > 0) {
console.log(i);
i++; // ❌ i oshib boradi, hech qachon 0 ga tushmaydii
// i-- bo'lishi kerak edi
}
length ni har iteratsiyada hisoblash:
// ❌ har iteratsiyada length qayta hisoblanadi
for (let i = 0; i < arr.length; i++) { }
// ✅ bir marta saqlab olinadi
const len = arr.length;
for (let i = 0; i < len; i++) { }
// Yoki for...of ishlatiladi — bu muammo yo'q
Xulosa
for — iteratsiya soni ma'lum bo'lganda. Massiv indeksi kerak bo'lganda.
while — shart qachon false bo'lishini bilmasangiz.
do...while — kamida bir marta bajarilishi kerak bo'lganda.
for...of — massiv, string va boshqa iterable lar uchun. Indeks kerak bo'lmasa eng qulay.
for...in — ob'ekt kalitlari uchun. Massiv uchun ishlatilmaydi.
break — sikldan chiqish. continue — bu iteratsiyani o'tkazib yuborish.
Keyingi dars
8-dars: Funksiyalar — declaration, expression, arrow function