4-bo‘lim
Sikllar
for, while, do...while, for...of va for...in sikllari, break va continue, ichma-ich sikllar va cheksiz sikldan saqlanish.
Ushbu bo‘lim mundarijasi
Kompyuterning eng katta afzalligi - charchamasdan takrorlash. Sikllar shu imkoniyatni beradi.
for sikli #
for (let i = 1; i <= 5; i++) {
console.log(`${i} - takrorlanish`);
}
1 - takrorlanish
2 - takrorlanish
3 - takrorlanish
4 - takrorlanish
5 - takrorlanish
while sikli #
let qoldiq = 100;
let oy = 0;
while (qoldiq > 0) {
qoldiq -= 30;
oy++;
}
console.log(`Qarz ${oy} oyda to'landi`);
console.log(`Oxirgi qoldiq: ${qoldiq}`);
Qarz 4 oyda to'landi
Oxirgi qoldiq: -20
| Sikl | Qachon |
|---|---|
for | Takrorlanishlar soni oldindan ma'lum |
while | Shart bo'yicha, soni noma'lum |
do...while | Kamida bir marta bajarilishi kerak |
for...of | Massiv yoki satr elementlari bo'yicha |
for...in | Obyekt kalitlari bo'yicha |
Amalda for...of va massiv metodlari (map, filter) eng ko'p
ishlatiladi. Klassik for esa indeks kerak bo'lganda qoladi.
do...while #
let urinish = 0;
do {
urinish++;
console.log(`${urinish}-urinish`);
} while (urinish < 3);
// Shart darhol yolg'on bo'lsa ham bir marta ishlaydi
let hech = 100;
do {
console.log("Bu baribir chiqadi");
} while (hech < 10);
1-urinish
2-urinish
3-urinish
Bu baribir chiqadi
for...of - eng qulay usul #
const mevalar = ["olma", "anor", "uzum"];
for (const meva of mevalar) {
console.log(meva);
}
// Satr ham element-element o'qiladi
for (const harf of "JS") {
console.log(harf);
}
// Indeks ham kerak bo'lsa
for (const [indeks, meva] of mevalar.entries()) {
console.log(`${indeks}: ${meva}`);
}
olma
anor
uzum
J
S
0: olma
1: anor
2: uzum
for...in - obyekt kalitlari #
const talaba = { ism: "Malika", yosh: 22, shahar: "Farg'ona" };
for (const kalit in talaba) {
console.log(`${kalit}: ${talaba[kalit]}`);
}
ism: Malika
yosh: 22
shahar: Farg'ona
for...in ni massivda ishlatmangfor...in kalitlar bo'yicha yuradi. Massivda kalitlar -
indekslar, lekin ular satr ko'rinishida keladi:
const sonlar = [10, 20, 30];
for (const i in sonlar) {
console.log(typeof i, i); // "string" 0, "string" 1, ...
}
Bu qo'shishda muammo tug'diradi:
for (const i in sonlar) {
console.log(i + 1); // "01", "11", "21" - satr ulanishi!
}
Yana bir muammo: for...in meros olingan xossalarni ham
ko'radi va tartibni kafolatlamaydi.
Qoida:
- Massiv uchun -
for...ofyoki massiv metodlari; - Obyekt uchun -
for...inyokiObject.keys().
break va continue #
const sonlar = [3, 7, 12, 8, 15, 4];
// break - siklni butunlay to'xtatadi
for (const son of sonlar) {
if (son > 10) {
console.log(`Birinchi katta son: ${son}`);
break;
}
}
// continue - shu takrorlanishni o'tkazib yuboradi
console.log("Toq sonlar:");
for (const son of sonlar) {
if (son % 2 === 0) {
continue;
}
console.log(" " + son);
}
Birinchi katta son: 12
Toq sonlar:
3
7
15
Ichma-ich sikllar #
// Ko'paytirish jadvali
for (let i = 2; i <= 4; i++) {
let qator = "";
for (let j = 1; j <= 5; j++) {
qator += `${i}x${j}=${i * j} `;
}
console.log(qator.trim());
}
2x1=2 2x2=4 2x3=6 2x4=8 2x5=10
3x1=3 3x2=6 3x3=9 3x4=12 3x5=15
4x1=4 4x2=8 4x3=12 4x4=16 4x5=20
Oddiy break faqat ichki siklni to'xtatadi. Ikkalasidan
chiqish uchun yorliq ishlatiladi:
tashqi:
for (let i = 0; i < 5; i++) {
for (let j = 0; j < 5; j++) {
if (i * j > 6) {
break tashqi; // ikkala sikldan chiqadi
}
}
}
Yorliqlar kamdan-kam kerak bo'ladi. Ko'p hollarda kodni
funksiyaga ajratib, return qilish tozaroq:
function qidirish(matritsa, nishon) {
for (const qator of matritsa) {
for (const katak of qator) {
if (katak === nishon) {
return true; // hamma sikldan chiqadi
}
}
}
return false;
}
Cheksiz sikl xavfi #
// XAVFLI NAQSH - i hech qachon oshmaydi
// while (i < 10) { console.log(i); }
// To'g'ri: hisoblagich albatta o'zgaradi
let i = 0;
let qadam = 0;
while (i < 10) {
i += 3;
qadam++;
// Xavfsizlik chegarasi - ishlab chiqishda foydali
if (qadam > 1000) {
console.log("Chegaraga yetildi - sikl to'xtatildi");
break;
}
}
console.log(`${qadam} qadamda i = ${i}`);
4 qadamda i = 12
JavaScript brauzerda bitta oqimda ishlaydi. Cheksiz sikl butun sahifani - tugmalarni, aylantirish, hatto yopish tugmasini ham - bloklab qo'yadi.
Eng ko'p uchraydigan sabablar:
// 1. Hisoblagichni oshirishni unutish
let i = 0;
while (i < 10) {
console.log(i); // i o'zgarmaydi!
}
// 2. Sikl ichida massivga element qo'shish
for (const x of royxat) {
royxat.push(x); // ro'yxat hech qachon tugamaydi
}
// 3. Suzuvchi nuqta bilan aniq taqqoslash
for (let x = 0; x !== 1; x += 0.1) {
// x hech qachon aynan 1 bo'lmaydi!
}
Uchinchisi ayniqsa xavfli - 2-bo'limdagi 0.1 + 0.2 muammosining
o'zi. !== o'rniga < ishlating.
Node.js da Ctrl+C yordam beradi, brauzerda esa yorliqni
majburan yopishga to'g'ri keladi.
Amaliy misol: ma'lumot yig'ish #
const xaridlar = [
{ mahsulot: "Non", narx: 5000, soni: 2 },
{ mahsulot: "Sut", narx: 12000, soni: 1 },
{ mahsulot: "Guruch", narx: 18000, soni: 3 }
];
let jami = 0;
let engQimmat = null;
for (const xarid of xaridlar) {
const summa = xarid.narx * xarid.soni;
jami += summa;
if (engQimmat === null || summa > engQimmat.summa) {
engQimmat = { nom: xarid.mahsulot, summa: summa };
}
console.log(`${xarid.mahsulot.padEnd(8)} ${summa} so'm`);
}
console.log("-".repeat(20));
console.log(`Jami: ${jami} so'm`);
console.log(`Eng katta: ${engQimmat.nom} (${engQimmat.summa} so'm)`);
Non 10000 so'm
Sut 12000 so'm
Guruch 54000 so'm
--------------------
Jami: 76000 so'm
Eng katta: Guruch (54000 so'm)
Sikl o'rniga massiv metodlari #
const sonlar = [1, 2, 3, 4, 5, 6];
// Sikl bilan
let juftlar1 = [];
for (const son of sonlar) {
if (son % 2 === 0) {
juftlar1.push(son);
}
}
// Metod bilan - bir qator
const juftlar2 = sonlar.filter((son) => son % 2 === 0);
console.log("Sikl bilan :", juftlar1);
console.log("Metod bilan:", juftlar2);
// Yig'indi
let yigindi1 = 0;
for (const son of sonlar) {
yigindi1 += son;
}
const yigindi2 = sonlar.reduce((jami, son) => jami + son, 0);
console.log("Yig'indi :", yigindi1, "va", yigindi2);
Sikl bilan : [ 2, 4, 6 ]
Metod bilan: [ 2, 4, 6 ]
Yig'indi : 21 va 21
filter va map klassik for dan biroz sekinroq ishlaydi -
ular har element uchun funksiya chaqiradi.
Lekin farq odatda millionlab element bo'lgandagina seziladi. Oddiy ro'yxatlarda (yuzlab, minglab element) farq mikrosekundlarda o'lchanadi va foydalanuvchi buni sezmaydi.
O'qilishi esa ancha yaxshi:
// Nima qilayotgani darhol ko'rinadi
const faolTalabalar = talabalar
.filter((t) => t.faol)
.map((t) => t.ism);
Qoida: avval o'qiladigan kod yozing. Tezlik muammosi haqiqatan paydo bo'lsa - o'lchang, keyin optimallashtiring.
7-bo'limda bu metodlarni batafsil ko'ramiz.
forbilan 1 dan 10 gacha sonlarni chiqaring.whilebilan qarzni oylik to'lov bilan yoping.do...whilekamida bir marta ishlashini isbotlang.for...ofbilan massiv va satrni aylantiring.entries()bilan indeks va qiymatni birga oling.for...inni massivda ishlatib,i + 1natijasini ko'ring.breakbilan birinchi mos elementni toping.continuebilan juft sonlarni o'tkazib yuboring.- Ichma-ich sikl bilan ko'paytirish jadvalini chizing.
filtervareducebilan siklni qisqartiring.
Xulosa #
for- takrorlanishlar soni ma'lum bo'lganda.while- shart bo'yicha, soni noma'lum.do...while- kamida bir marta bajariladi.for...ofmassiv va satr elementlari uchun eng qulay.for...inobyekt kalitlari uchun; massivda ishlatmang.for...inindekslarni satr sifatida beradi.breaksiklni to'xtatadi,continuebitta qadamni o'tkazadi.- Ichma-ich sikldan chiqish uchun yorliq yoki
return. - Cheksiz sikl brauzerda butun sahifani muzlatadi.
- Suzuvchi nuqtali hisoblagichda
!==emas,<ishlating. - Massiv metodlari sikldan o'qilishi qulayroq.
Keyingi bo'limda funksiyalar bilan tanishamiz.
O‘qish tarixini saqlamoqchimisiz?
Tizimga kirsangiz, tugatgan bo‘limlaringiz saqlanadi va qoldirgan joyingizdan davom etasiz.
Xatolik topdingizmi?
Imlo xatosi, ishlamaydigan kod yoki noto‘g‘ri ma‘lumotni ko‘rsangiz - bizga xabar bering. Har bir xabar administrator tomonidan ko‘rib chiqiladi.