# Tsikllar — 2-qism: until, break/continue, ichma-ich, C-style for !!! info "Bu darsda" - 🎯 `until` tsiklini — `while`ning "aksi"ni — qachon va qanday ishlatishni o'rganasiz - 🎯 `break` va `continue` bilan tsikl oqimini boshqarishni ko'rasiz - 🎯 Ichma-ich tsikllardan to'g'ri chiqishni (`break 2`) o'rganasiz - 🎯 C-style `for` sintaksisini tushunasiz - ⏱️ O'qish vaqti: ~15 daqiqa - 🧩 Kerakli bilim: [6.1 — For va While tsikllar](6.1%20Loops.md) --- ## 🪝 Tasavvur qiling... Siz server skripti yozmoqdasiz. Vazifa oddiy: database ishga tushguncha kuting, tayyor bo'lgach — davom eting. `while` bilan yozsangiz shunday chiqadi: ```bash while [ "$db_ready" = false ]; do # "tayyor EMAS" ekan, davom et sleep 1 done ``` Lekin bu mantiq biroz bosh qotiradi: "tayyor emas ekan, davom et" — negativ shart. Ko'p hollarda shunday o'qish aniqroq bo'ladi: **"tayyor bo'lguncha kut"**. Aynan shu uchun `until` mavjud. --- ## until tsikli — "bo'lguncha kut" `while [ shart ]` → shart **rost** bo'lsa ishlaydi. `until [ shart ]` → shart **yolg'on** bo'lsa ishlaydi (ya'ni, shart rost bo'lguncha). !!! tip "Oddiy qilib aytganda" `while` — "shamol bo'lsa turing". `until` — "shamol to'xtaguncha turing". Bir xil natija, lekin ikkinchisi ba'zan o'qishga tabiiyligi. ### Sintaksis ```bash until [ shart ]; do # shart yolg'on bo'lguncha shu yerga kiriladi done ``` ### Eng klassik misol: server tayyor bo'lguncha kutish ```bash #!/bin/bash db_ready=false wait_time=0 max_wait=30 # 30 soniyadan ko'p kutmaslik # "db_ready rost bo'lguncha" — ya'ni tayyor bo'lguncha kut until [ "$db_ready" = true ] || [ $wait_time -ge $max_wait ]; do ((wait_time++)) echo "Kutilmoqda... ${wait_time}s" # Database ping tekshiruvi (real holatda: pg_isready, mysqladmin ping) if pg_isready -q 2>/dev/null; then db_ready=true echo "Database tayyor! (${wait_time}s ichida)" else sleep 1 fi done if [ "$db_ready" = false ]; then echo "Xato: database ${max_wait}s ichida ishga tushmadi" >&2 exit 1 fi ``` !!! warning "Tez-tez uchraydigan xato" `until` ham xuddi `while` kabi cheksiz tsiklga tushib qolishi mumkin. **Har doim** `max_wait` yoki `max_attempts` kabi chek qo'ying — aks holda skript abadiy kutishda qoladi.

Chuqurroq — until vs while: qaysi birini tanlash?

Ikkisi ham bir xil ishni bajaradi. Qaysi biri yaxshi — bu uslub masalasi: | Holat | Tavsiya | |---|---| | Shart "to'g'ridan-to'g'ri ijobiy" bo'lsa | `while` qulay: `while [ $count -lt 10 ]` | | Shart "biror narsani kutish" bo'lsa | `until` tabiiy: `until [ "$ready" = true ]` | | Negatsiya bilan bosh qotirsangiz | `while` ishlating, `until`ni majburlamang | Ko'pchilik tajribali skript yozuvchilar `until`ni asosan "polling" (muntazam tekshiruv) holatida — port ochilguncha, fayl paydo bo'lguncha, servis tayyor bo'lguncha — ishlatadi. ```bash # Port 8080 ochilguncha kut until nc -z localhost 8080 2>/dev/null; do echo "Port 8080 hali yopiq, kutilmoqda..." sleep 2 done echo "Port 8080 tayyor!" ```

--- ## 💻 O'zingiz sinab ko'ring — 1 Quyidagi skriptni `until_demo.sh` nomli faylga yozing va ishga tushiring: ```bash #!/bin/bash # Countdown: 5 dan 0 gacha sanash counter=5 until [ $counter -eq 0 ]; do echo "$counter..." ((counter--)) # counter ni 1 ga kamaytir sleep 1 done echo "Vaqt tugadi!" ``` Kutilgan natija: `5...`, `4...`, `3...`, `2...`, `1...`, `Vaqt tugadi!` !!! question "Tekshirib ko'ring" Yuqoridagi `until [ $counter -eq 0 ]` ni `while` bilan qayta yozsangiz, shart qanday bo'lishi kerak?

Javob — bosib oching

```bash while [ $counter -gt 0 ]; do ... done ``` `until [ $counter -eq 0 ]` — "0 bo'lguncha ishlat" `while [ $counter -gt 0 ]` — "0 dan katta bo'lsa ishlat" Natija bir xil, shart esa teskarisi.

--- ## break va continue — tsikl oqimini boshqarish Tsikl har doim oxirigacha borishi shart emas. Ba'zan: - Ma'lum bir element topilganda **to'xtatish** kerak — `break` - Bitta elementni **o'tkazib yuborish** kerak — `continue` !!! tip "Oddiy qilib aytganda" `break` — "qoching, o'yin tugadi!" `continue` — "bu qadamni o'tkazib yubor, keyingisiga o't." ### break — tsikldan chiqish ```bash #!/bin/bash users=("ahmad" "dilshod" "madina" "jasur" "zarina") search_user="madina" found=false for user in "${users[@]}"; do echo "Tekshirilmoqda: $user" if [ "$user" = "$search_user" ]; then echo "Topildi: $user" found=true break # Topildi — qolganlarni tekshirishning hojati yo'q fi done if [ "$found" = false ]; then echo "$search_user topilmadi" fi ``` `break` chaqirilganda tsikl darhol to'xtaydi. "Madina" topilgandan so'ng "jasur" va "zarina" tekshirilmaydi — bu samaradorlikdir. ### continue — joriy iteratsiyani o'tkazib yuborish ```bash #!/bin/bash items=("item1" "SKIP" "item2" "ERROR" "item3") processed=0 for item in "${items[@]}"; do # "SKIP" yoki "ERROR" bo'lsa — bu elementni o'tkazib yubor if [[ "$item" == "SKIP" || "$item" == "ERROR" ]]; then echo "O'tkazib yuborildi: $item" continue # Pastdagi kod bajarilmaydi, keyingi elementga o'tiladi fi # Faqat oddiy elementlar shu yerga yetib keladi echo "Qayta ishlandi: $item" ((processed++)) done echo "Jami qayta ishlandi: $processed ta" ``` ### break va continue birgalikda — xato bilan ishlash ```bash #!/bin/bash # Fayllarni qayta ishlash: bo'sh fayllarni o'tkazib yubor, # ko'p xato bo'lsa to'xtat max_errors=2 error_count=0 processed_count=0 for file in /var/log/app/*.log; do # Bo'sh fayl bo'lsa — o'tkazib yubor if [ ! -s "$file" ]; then echo "Bo'sh fayl, o'tkazib yuborildi: $file" continue fi # Fayl ichida "CRITICAL" so'z bor-yo'qligini tekshir if grep -q "CRITICAL" "$file"; then ((error_count++)) echo "Kritik xato: $file ($error_count/$max_errors)" # Xato chegarasiga yetilsa — to'xtat if [ $error_count -ge $max_errors ]; then echo "Maksimal xato soni yetdi, to'xtatilmoqda!" break fi continue # Kritik faylni qayta ishlamasdan keyingisiga o't fi # Oddiy, xatosiz fayl ((processed_count++)) echo "Qayta ishlandi: $file" done echo "Natija: $processed_count qayta ishlandi, $error_count xato" ``` --- ## 💻 O'zingiz sinab ko'ring — 2 ```bash #!/bin/bash # 1 dan 20 gacha sanab, faqat 3 ga bo'linadigan sonlarni chop eting # 15 ga yetganda to'xtang for i in {1..20}; do if [ $i -gt 15 ]; then break fi if [ $((i % 3)) -ne 0 ]; then continue fi echo "$i" done ``` !!! question "Tekshirib ko'ring" Yuqoridagi skript qanday sonlarni chiqaradi? Ishga tushirmasdan avval taxmin qiling.

Javob — bosib oching

Chiqadi: `3`, `6`, `9`, `12`, `15` - `break` 15 dan katta sonlarda ishlaydi — ya'ni 16, 17... ko'rinmaydi - `continue` 3 ga bo'linmaydigan sonlarda ishlaydi — ular o'tkazib yuboriladi - 15 ning o'zi ko'rinadi, chunki `i -gt 15` sharti 15 ga mos kelmaydi (15 > 15 yolg'on)

--- ## Ichma-ich tsikllar va break 2 Tsikl ichida tsikl bo'lishi mumkin. Buni **ichma-ich tsikl** (nested loop) deyiladi. ```mermaid flowchart TD A[Tashqi tsikl: i = 1..3] --> B{i tugadimi?} B -- Ha --> G[Tugatildi] B -- Yo'q --> C[Ichki tsikl: j = 1..3] C --> D{j tugadimi?} D -- Ha --> B D -- Yo'q --> E[i va j bilan ish baj.] E --> D ``` ### Oddiy ichma-ich misol — ko'paytirish jadvali ```bash #!/bin/bash # Ko'paytirish jadvali (3x3) for ((i=1; i<=3; i++)); do for ((j=1; j<=3; j++)); do printf "%4d" $((i * j)) # 4 belgili ustunda chiqar done echo # Yangi qator done ``` Natija: ``` 1 2 3 2 4 6 3 6 9 ``` ### break 2 — ikki darajali tsikldan chiqish Oddiy `break` faqat **eng ichki** tsikldan chiqadi. Agar tashqi tsikldan ham chiqish kerak bo'lsa — `break 2` ishlatiladi. ```bash #!/bin/bash # Ko'paytirish jadvalida 50 dan katta birinchi qiymatni top for i in {1..10}; do for j in {1..10}; do product=$((i * j)) if [ $product -gt 50 ]; then echo "Topildi: $i x $j = $product" break 2 # Ikki darajali tsikldan ham chiq fi done done echo "Qidiruv tugadi" ``` !!! warning "Tez-tez uchraydigan xato" `break 2` o'rniga oddiy `break` yozsangiz — faqat ichki tsikldan chiqiladi, tashqi tsikl davom etaveradi. Bu esa noto'g'ri natijaga olib keladi: birinchi topilgandan keyin ham tsikl ishlashda davom etadi.

Chuqurroq — break N va continue N qoidasi

`break N` va `continue N` — N ta ichki tsiklga ta'sir qiladi: ```bash for i in {1..3}; do # 1-daraja for j in {1..3}; do # 2-daraja for k in {1..3}; do # 3-daraja if [ $k -eq 2 ]; then break 2 # 2 va 3-darajali tsikllardan chiqadi # 1-darajali tsikl davom etadi fi echo "$i $j $k" done done done ``` `continue 2` ham xuddi shunday ishlaydi: 2-daraja tsiklning joriy iteratsiyasini o'tkazib yuboradi. Amalda `break 3` va undan yuqori kamdan-kam ishlatiladi. Agar 3+ darajali tsikl boshqarish kerak bo'lsa — funksiyalarga ajrating, bu aniqroq bo'ladi.

--- ## C-style for tsikli Bash da C tiliga o'xshash `for` sintaksisi mavjud. Bu ayniqsa hisoblagichli tsikllarda qulay. ```bash for ((boshlang'ich; shart; qadam)); do # tana done ``` ### Misol — klassik hisoblagich ```bash #!/bin/bash # 0 dan 4 gacha (C-style) for ((i=0; i<5; i++)); do echo "i = $i" done ``` ### Misol — teskari hisoblash ```bash #!/bin/bash # 10 dan 1 gacha — i-- bilan for ((i=10; i>=1; i--)); do echo "$i" done echo "Start!" ``` ### Misol — 2 taga sakrab ```bash #!/bin/bash # 0 dan 20 gacha, har safar 2 ga oshib — i+=2 for ((i=0; i<=20; i+=2)); do echo -n "$i " # -n: yangi qatorsiz chiqar done echo # Oxirida yangi qator ``` Natija: `0 2 4 6 8 10 12 14 16 18 20` !!! tip "Oddiy qilib aytganda" C-style `for` — siz uchta narsani o'zingiz boshqarasiz: **boshlang'ich qiymat**, **to'xtash sharti**, **qadamlar**. `{1..10}` formasi oddiyroq, lekin faqat butun sonlar uchun. C-style esa ko'proq moslashuvchan.

Chuqurroq — C-style for va {..} brace expansion farqi

| | `{start..end}` | `((i=start; i<=end; i++))` | |---|---|---| | O'qish osonligi | Juda oson | O'rtacha | | O'zgaruvchi qadam | Yo'q (`{1..10..2}` ishlaydi) | Ha (`i+=5`) | | Hisoblash ichida | Yo'q | Ha (`i*=2`) | | Manfiy qadamlar | Qisman (`{10..1}`) | Ha | | Bash versiyasi | 3.0+ | 2.05+ | Amaliy maslahat: oddiy `{1..10}` uchun brace expansion aniqroq. Murakkab qadam yoki hisoblash kerak bo'lsa — C-style. ```bash # Fayl hajmini ikki barobar oshirib tekshirish: 1KB, 2KB, 4KB... for ((size=1; size<=64; size*=2)); do dd if=/dev/zero of=test_${size}k.bin bs=1024 count=$size 2>/dev/null echo "${size}KB fayl yaratildi" done ```

--- ## 💻 O'zingiz sinab ko'ring — 3 Amaliy DevOps vazifasi: portlarni tekshiruvchi skript. ```bash #!/bin/bash # Keng tarqalgan portlar ro'yxatini tekshir # Agar 3 ta ochiq port topilsa — to'xtat declare -a common_ports=(22 80 443 3306 5432 6379 8080 8443 27017) open_count=0 max_open=3 # 3 tadan keyin to'xtat echo "Port tekshiruvi boshlanmoqda..." for port in "${common_ports[@]}"; do # nc (netcat) bilan port tekshiruvi: -z = faqat tekshir, -w1 = 1 soniya timeout if nc -z -w1 localhost "$port" 2>/dev/null; then echo "OCHIQ: $port" ((open_count++)) if [ $open_count -ge $max_open ]; then echo "$max_open ta ochiq port topildi, to'xtatilmoqda." break fi else echo "yopiq: $port" fi done echo "Jami ochiq portlar: $open_count" ``` Uni `port_check.sh` ga yozing, `chmod +x port_check.sh` bering va `./port_check.sh` bilan ishga tushiring. --- ## Hamma narsani birlashtirgan amaliy misol Bu misol `until`, `break`, `continue` va C-style `for` ni birgalikda ko'rsatadi — log faylni tahlil qiluvchi skript: ```bash #!/bin/bash # Log fayl tahlilchisi # - until: yangi yozuv paydo bo'lguncha kut # - continue: INFO darajasini o'tkazib yubor # - break: 3 ta ERROR topilganda to'xtat LOG_FILE="/var/log/app.log" MAX_ERRORS=3 error_count=0 processed=0 echo "Log tahlil boshlanmoqda: $LOG_FILE" # Fayl paydo bo'lguncha kut (until) until [ -f "$LOG_FILE" ]; do echo "Log fayl kutilmoqda..." sleep 2 done echo "Fayl topildi, o'qilmoqda..." while IFS= read -r line; do ((processed++)) # Daraja ajratib olish (uchinchi ustun) level=$(echo "$line" | awk '{print $3}') # INFO yozuvlarini o'tkazib yubor (continue) if [ "$level" = "INFO" ]; then continue fi # ERROR hisoblash if [ "$level" = "ERROR" ]; then ((error_count++)) echo "[$error_count] XATO TOPILDI: $line" # 3 ta ERROR bo'lganda to'xtat (break) if [ $error_count -ge $MAX_ERRORS ]; then echo "Kritik chegara yetildi ($MAX_ERRORS xato). To'xtatilmoqda." break fi fi # WARN va boshqa darajalar if [ "$level" = "WARN" ]; then echo "Ogohlantirish: $line" fi done < "$LOG_FILE" echo "" echo "--- Natija ---" echo "Ko'rib chiqildi: $processed qator" echo "Xatolar: $error_count ta" ``` --- ## 🎒 Xulosa — eng muhimi Agar bu darsdan 4 narsani eslab qolsangiz: 1. **`until [ shart ]`** — shart rost bo'lguncha ishlaydi. "Bo'lguncha kut" mantiqida `while` dan ko'ra tabiiyroq. 2. **`break`** — tsiklni to'xtatadi. **`break 2`** — ikki darajali ichma-ich tsikldan chiqadi. 3. **`continue`** — joriy iteratsiyani o'tkazib yuboradi, tsiklni to'xtatmaydi. 4. **C-style `for ((i=0; i