# Kirish va Chiqish — Skriptingiz bilan gaplashish !!! info "Bu darsda" - 🎯 Skript foydalanuvchidan ma'lumot qanday olishini (`read`) bilib olasiz - 🎯 `echo` va `printf` farqini, rangli va formatlangan output'ni o'rganasiz - 🎯 Argumentlar (`$1`, `$@`, `$#`) nima va ularni qanday ishlatishni tushunasiz - 🎯 Fayl va pipeline input/output bilan ishlaysiz - ⏱️ O'qish vaqti: ~15 daqiqa - 🧩 Kerakli bilim: oldingi darslar — o'zgaruvchilar, tsikllar --- ## 🪝 Siz ATM apparatining oldida turibsiz Tasavvur qiling: siz bank kartangizni kiritdingiz. Ekranda yozuv paydo bo'ldi: "PIN-kod kiriting." Siz raqamlarni bosasiz — apparat **eshitadi** (input). Keyin ekranda "Muvaffaqiyatli" yoki "Noto'g'ri PIN" chiqadi — apparat **gapiradi** (output). Siz yozadigan har bir bash skripti ham xuddi shu ATM kabi ishlaydi: - **Kirish (Input):** foydalanuvchidan so'raydi, argumentlar oladi, fayldan o'qiydi. - **Chiqish (Output):** ekranga yozadi, fayllarga saqlaydi, boshqa dasturlarga uzatadi. Bu darsda o'sha "ATM" mantiqini qurishni o'rganasiz. --- ## Kirish (Input) ### `read` — foydalanuvchidan so'rash Eng oddiy holat: skript to'xtab, foydalanuvchi nimadir yozishini kutadi. !!! tip "Oddiy qilib aytganda" `read` — bu skriptingizning "qulog'i". U klaviaturadan matn o'qib, o'zgaruvchiga saqlaydi. ```bash #!/bin/bash # Foydalanuvchidan ism so'rash echo "Ismingizni kiriting:" read user_name # foydalanuvchi yozgani user_name ga saqlanadi echo "Salom, $user_name!" ``` Bu kodni ishga tushirsangiz, skript "Ismingizni kiriting:" deb to'xtaydi va siz Enter bossangizgina davom etadi. #### `read` ning asosiy parametrlari | Parametr | Vazifasi | Misol | |---|---|---| | `-p "Matn"` | Savolni alohida `echo` siz chiqaradi | `read -p "Ism: " nom` | | `-s` | Kiritilgan matn ekranda ko'rinmaydi (parol) | `read -s -p "Parol: " pwd` | | `-t 10` | 10 soniya kutadi, keyin davom etadi | `read -t 10 -p "Ism: " nom` | | `-r` | Teskari chiziq `\` ni oddiy belgi deb qabul qiladi | `read -r full_line` | | `-a` | Bir nechta so'zni massivga saqlaydi | `read -a colors` | ```bash #!/bin/bash # -p: bir qatorda so'rash (echo + read birga) read -p "Yoshingizni kiriting: " user_age echo "Siz $user_age yoshdasiz" # -s: parol — ekranda ko'rinmaydi read -s -p "Parolni kiriting: " user_password echo # yangi qatorga o'tish (parol kiritganda Enter ko'rinmaydi) echo "Parol uzunligi: ${#user_password} belgi" # -t: vaqt chegarasi echo "10 soniya ichida ismingizni kiriting:" if read -t 10 -p "Ism: " timed_name; then echo "Rahmat, $timed_name!" else echo "Vaqt tugadi! Default ism ishlatiladi." timed_name="Anonymous" fi ``` #### Bir vaqtda bir nechta qiymat ```bash #!/bin/bash # Ism va familiya — bo'shliqda bo'linadi read -p "Ism va familiyangizni kiriting: " first_name last_name echo "To'liq ism: $first_name $last_name" # Massivga o'qish (-a) read -p "Ranglaringizni kiriting (bo'shliq bilan): " -a colors echo "Siz ${#colors[@]} ta rang kirdingiz:" for i in "${!colors[@]}"; do echo " $((i+1)). ${colors[i]}" done # Butun qatorni bir o'zgaruvchiga (-r muhim!) read -r -p "Uzun matn: " full_line echo "Siz yozdingiz: $full_line" ``` !!! warning "Tez-tez uchraydigan xato" `-r` parametrisiz `read` teskari chiziq `\` ni "davom etish" belgisi sifatida talqin qiladi. Siz `C:\Windows` kiritsangiz, `C:Windows` chiqadi. Odatda **har doim `-r` ishlating**. --- ### Argumentlar — skriptni ishga tushirishda ma'lumot berish Ba'zan skriptni ishga tushirishda qiymatlarni oldindan berasiz — xuddi buyruqqa qo'shimcha ko'rsatma kabi: !!! tip "Oddiy qilib aytganda" Oshxonaga borgan xizmatchi kabi tasavvur qiling: `./skript.sh Ahmad 25 Toshkent` — siz xizmatchi (skript) oldiga borib, "Ahmad uchun, 25 ta, Toshkentga yetkazib ber" deysiz. Xizmatchi hech narsani sizdan so'ramasdan, siz boshida aytgan buyurtmani bajaradi. `$1`, `$2`, `$3` — o'sha buyurtma qog'ozidagi birinchi, ikkinchi, uchinchi punkt. ```bash ./mening_skriptim.sh Ahmad 25 Toshkent ``` Bu qiymatlar skript ichida maxsus o'zgaruvchilar orqali mavjud: ```mermaid flowchart LR A["./skript.sh Ahmad 25 Toshkent"] --> B["$0 = ./skript.sh
$1 = Ahmad
$2 = 25
$3 = Toshkent"] B --> C["$# = 3
$@ = Ahmad 25 Toshkent
$* = Ahmad 25 Toshkent"] style A fill:#1e3a8a,stroke:#60a5fa,color:#fff style B fill:#065f46,stroke:#34d399,color:#fff ``` | O'zgaruvchi | Ma'nosi | |---|---| | `$0` | Skriptning o'z nomi (fayl yo'li) | | `$1`, `$2`, ... | 1-argument, 2-argument, ... | | `$#` | Argumentlar soni | | `$@` | Barcha argumentlar (alohida-alohida, `for` da qulay) | | `$*` | Barcha argumentlar (bitta matn sifatida) | ```bash #!/bin/bash echo "Script nomi: $0" echo "Argumentlar soni: $#" # Argument berilmagan bo'lsa, yordam ko'rsat if [[ $# -eq 0 ]]; then echo "Ishlatish: $0 ..." exit 1 fi echo "Birinchi argument: $1" echo "Ikkinchi argument: $2" echo "Barcha argumentlar: $@" # $@ ustida tsikl — har bir argumentni alohida qayta ishlash for arg in "$@"; do echo " -> $arg" done ``` !!! question "Tekshirib ko'ring" `$@` va `$*` o'rtasidagi farq qachon ahamiyatli bo'ladi?

Javob — bosib oching

Farq bo'shliqli argumentlarda ko'rinadi. Masalan, `./skript.sh "Ahmad Karimov" 25` deb chaqirsangiz: - `"$@"` — ikkita element: `"Ahmad Karimov"` va `"25"` (to'g'ri) - `"$*"` — bitta element: `"Ahmad Karimov 25"` (noto'g'ri) `for arg in "$@"` — har doim to'g'ri. `$*` — kamdan-kam hollarda kerak.

🔬 Chuqurroq — argumentlarni shift va getopts bilan boshqarish

**`shift` — argumentlarni "surib" oldinga olish:** ```bash #!/bin/bash # shift har safar $1 ni o'chirib, qolganlarni suradi while [[ $# -gt 0 ]]; do echo "Hozirgi argument: $1" shift # $2 -> $1, $3 -> $2 ... done ``` **`getopts` — `-v`, `-f fayl` kabi flaglar uchun:** ```bash #!/bin/bash while getopts "n:a:v" opt; do case $opt in n) name="$OPTARG" ;; # -n Ahmad a) age="$OPTARG" ;; # -a 25 v) verbose=true ;; # -v (qiymatsiz flag) esac done echo "Ism: $name, Yosh: $age" ``` Ishlatish: `./skript.sh -n Ahmad -a 25 -v`

--- ### Fayldan o'qish va pipeline #### Pipe (`|`) — buyruqlarni zanjirga ulash !!! tip "Oddiy qilib aytganda" Zavod konveyerini tasavvur qiling: birinchi ishchi xomashyo kesadi, ikkinchisiga uzatadi, ikkinchi bo'yaydi, uchinchisiga uzatadi, uchinchi qadoqlaydi. Pipe (`|`) — o'sha uzatish tasmasi. Birinchi buyruq chiqargan natija ikkinchi buyruqning kirishiga aylanadi — hech qanday oraliq fayl kerak emas. ```mermaid flowchart LR A["ls /etc"] -->|"stdout"| B["grep '.conf'"] B -->|"stdout"| C["wc -l"] C --> D["Natija: 42"] style A fill:#1e3a8a,stroke:#60a5fa,color:#fff style B fill:#065f46,stroke:#34d399,color:#fff style C fill:#7c2d12,stroke:#fb923c,color:#fff style D fill:#374151,stroke:#9ca3af,color:#fff ``` `ls /etc | grep '.conf' | wc -l` — uchta buyruq, bitta qator, bitta natija. ```bash #!/bin/bash # Pipeline: boshqa buyruq chiqishidan o'qish ls /etc | while read -r filename; do echo "Topildi: $filename" done # Amaliy misol: faqat .conf fayllarni sanash conf_count=$(ls /etc | grep -c '\.conf') echo "Config fayllari soni: $conf_count" # Pipeline + while read — har qatorni qayta ishlash ps aux | grep nginx | while read -r line; do echo "Nginx jarayoni: $line" done ``` #### Fayldan o'qish ```bash #!/bin/bash # Faylni qatorma-qator o'qish while IFS= read -r line; do echo "Qator: $line" done < /etc/hostname # fayl skriptga "kirish" sifatida beriladi # CSV fayl bilan ishlash # Fayl tarkibi: name,age,city while IFS=',' read -r name age city; do echo "$name ($age yosh) — $city" done < users.csv ``` !!! tip "Oddiy qilib aytganda" `< fayl` — bu "faylni skriptga uzat" degani. `IFS=','` esa "bo'lish belgisi vergul" degani (odatda bo'shliq). --- ### Validatsiya — kiritilganini tekshirish Real skriptlarda foydalanuvchi noto'g'ri kiritishi mumkin. Tekshirish majburiy: !!! tip "Oddiy qilib aytganda" Bankomat sizga harflar kiritishga imkon bermaydi — faqat raqam qabul qiladi. Agar noto'g'ri bo'lsa, qaytadan so'raydi. Validatsiya — skriptingizning o'sha "bankomat filtri": noto'g'ri kiritilsa, to'g'rilari kiritilgunga qadar qayta so'raydi. ```bash #!/bin/bash # Raqam kiritilishini majburlash while true; do read -p "Yoshingizni kiriting (1-120): " age # =~ operator regex bilan tekshiradi if [[ "$age" =~ ^[0-9]+$ ]] && [[ $age -ge 1 ]] && [[ $age -le 120 ]]; then echo "To'g'ri: $age" break else echo "Xato! 1-120 oralig'ida raqam kiriting." fi done # Menyu — faqat ruxsat etilgan tanlovlar echo "Tanlang:" echo "1) Python 2) JavaScript 3) C++" while true; do read -p "Tanlov (1-3): " choice case $choice in 1) echo "Python!"; break ;; 2) echo "JavaScript!"; break ;; 3) echo "C++!"; break ;; *) echo "1, 2 yoki 3 kiriting." ;; esac done ``` --- ## 💻 O'zingiz sinab ko'ring — 1 Quyidagi skriptni yarating va ishga tushiring: ```bash #!/bin/bash # Fayl nomi: salomlashish.sh read -p "Ismingiz: " ism read -p "Yoshingiz: " yosh echo "Salom, $ism!" if [[ $yosh -lt 18 ]]; then echo "Siz hali yoshsiz." elif [[ $yosh -lt 60 ]]; then echo "Siz yosh va faolsiz." else echo "Siz tajribali insonkisiz." fi ``` Ishga tushirish: `bash salomlashish.sh` Kutilgan natija: siz kiritgan ism va yoshga qarab turli xabar chiqadi. --- ## Chiqish (Output) ### `echo` — oddiy chiqarish `echo` — eng ko'p ishlatiladigan buyruq. Lekin uning nozikliklari bor: ```bash #!/bin/bash echo "Oddiy matn" echo "Birinchi" "Ikkinchi" # bo'shliq bilan chiqaradi echo -n "Yangi qatorsiz " # -n: yangi qator qo'shmaslik echo "davomi" # bitta qatorda chiqadi echo -e "Maxsus belgilar:\n\tTab bilan yangi qator" # -e: maxsus belgilarni talqin qiladi # \n = yangi qator, \t = tab, \a = signal tovushi ``` | `echo` parametri | Vazifasi | |---|---| | `-n` | Oxirida yangi qator qo'shmaslik | | `-e` | `\n`, `\t` kabi maxsus belgilarni ishlatish | --- ### `printf` — formatlangan chiqarish `printf` — C tilidan kelgan, aniqroq format bilan chiqarish uchun. !!! tip "Oddiy qilib aytganda" `echo` — oddiy "ayt". `printf` — "aynan mana bu formatda ayt". Raqam kengligi, verguldan keyingi o'rinlar kerak bo'lsa — `printf`. ```bash #!/bin/bash # Asosiy format belgilari: # %s = matn (string), %d = butun son, %f = kasr son printf "Ism: %s, Yosh: %d, Baho: %.2f\n" "Ahmad" 25 98.75 # Natija: Ism: Ahmad, Yosh: 25, Baho: 98.75 printf "Raqam: %05d\n" 42 # 5 o'rin, nollar bilan to'ldirish: 00042 printf "Protsent: %d%%\n" 85 # %% = haqiqiy foiz belgisi: 85% # Formatlangan jadval printf "%-15s %-8s %-12s\n" "ISM" "YOSH" "SHAHAR" printf "%-15s %-8s %-12s\n" "---" "----" "------" printf "%-15s %-8d %-12s\n" "Ahmad Karimov" 25 "Toshkent" printf "%-15s %-8d %-12s\n" "Dilshod Umarov" 30 "Samarqand" # - belgisi: chapga tekislash. 15 = ustun kengligi ```

🔬 Chuqurroq — printf format belgilari to'liq ro'yxati

| Format | Ma'nosi | Misol | |---|---|---| | `%s` | Matn (string) | `%s` → `"Ahmad"` | | `%d` | Butun son (integer) | `%d` → `25` | | `%f` | Kasr son (float) | `%.2f` → `98.75` | | `%e` | Ilmiy notation | `%e` → `9.87e+01` | | `%x` | O'n oltilik (hex) | `%x` → `ff` | | `%o` | Sakkizlik (octal) | `%o` → `377` | | `%%` | Haqiqiy `%` belgisi | `%%` → `%` | | `%05d` | 5 o'rin, nollar bilan | `%05d` → `00042` | | `%-15s` | Chapga tekislash, 15 o'rin | `%-15s` → `Ahmad ` | | `%+d` | Ishorali raqam | `%+d` → `+25` |

--- ### Rangli chiqarish Terminal rangi ANSI escape kodi bilan boshqariladi. DevOps skriptlarida log darajalari uchun juda qulay. !!! tip "Oddiy qilib aytganda" `\033[0;31m` — terminalga "Hozirdan qizil rang yoz" deydi. `\033[0m` — "Rangni qaytar" deydi. Uni doim oxirida yozing, aks holda butun terminal qizil bo'lib qoladi. ```bash #!/bin/bash # Rang konstantalari RED='\033[0;31m' GREEN='\033[0;32m' YELLOW='\033[1;33m' BLUE='\033[0;34m' CYAN='\033[0;36m' NC='\033[0m' # No Color — rangni qaytarish echo -e "${RED}Xato xabari${NC}" echo -e "${GREEN}Muvaffaqiyat${NC}" echo -e "${YELLOW}Ogohlantirish${NC}" echo -e "${BLUE}Ma'lumot${NC}" # Fon rangi echo -e "\033[41mQizil fon\033[0m" echo -e "\033[42mYashil fon\033[0m" # Matn uslubi echo -e "\033[1mQalin matn\033[0m" echo -e "\033[4mPastiga chizilgan\033[0m" ``` --- ### Logging — real skriptlar uchun Production skriptlarida oddiy `echo` yetarli emas. Vaqt muhri va daraja kerak: !!! tip "Oddiy qilib aytganda" Kasalxona jurnalini tasavvur qiling: har bir yozuv aniq vaqt (`09:42`), kim yozgani (`DR. KARIMOV`) va daraja (`SHOSHILINCH` / `ODDIY`) bilan boshlanadi. Oddiy `echo` — "kimdir nimadir yozdi". Logging — "aynan kim, qachon, qanchalik muhim". Bir oydan keyin muammo izlayotganda siz jurnal yozib qo'yganingizga shukr qilasiz. ```bash #!/bin/bash # Log funksiyalari — bir marta yozing, hamma joyda ishlating log_info() { echo -e "\033[32m[INFO]\033[0m $(date '+%Y-%m-%d %H:%M:%S') $*" } log_warn() { echo -e "\033[33m[WARN]\033[0m $(date '+%Y-%m-%d %H:%M:%S') $*" } log_error() { # Xato xabarlari stderr (>&2) ga boradi — pipeline'ni buzmaslik uchun echo -e "\033[31m[ERROR]\033[0m $(date '+%Y-%m-%d %H:%M:%S') $*" >&2 } log_debug() { # DEBUG=true bo'lganda chiqadi, aks holda sukut if [[ "${DEBUG:-false}" == "true" ]]; then echo -e "\033[36m[DEBUG]\033[0m $(date '+%Y-%m-%d %H:%M:%S') $*" fi } # Ishlatish log_info "Application ishga tushdi" log_warn "Config topilmadi, default qiymatlar ishlatiladi" log_error "Database'ga ulanib bo'lmadi" DEBUG=true log_debug "username=admin, port=5432" ```

🔬 Chuqurroq — stdout va stderr farqi, stream yo'naltirish

Linux'da har bir jarayon uchta standart kanal bilan ishlaydi: ```mermaid flowchart LR A[Skript] -->|"stdout (1)"| B[Terminal ekrani] A -->|"stderr (2)"| C[Terminal ekrani yoki log fayl] D[Klaviatura/fayl] -->|"stdin (0)"| A style A fill:#1e3a8a,stroke:#60a5fa,color:#fff ``` | Kanal | Raqam | Maqsad | |---|---|---| | `stdin` | 0 | Kirish — klaviatura yoki fayl | | `stdout` | 1 | Oddiy chiqish — ekran | | `stderr` | 2 | Xato xabarlari — ekran yoki log | **Yo'naltirish operatorlari:** ```bash ./skript.sh > natija.txt # stdout ni faylga ./skript.sh 2> xatolar.txt # stderr ni faylga ./skript.sh > natija.txt 2>&1 # ikkalasini bir faylga ./skript.sh 2>/dev/null # xatolarni "yo'q" qilish echo "Qo'shiladi" >> fayl.txt # stdout ni faylga QO'SHISH (o'chirmaydi) ```

--- ### Faylga yozish ```bash #!/bin/bash # Faylga yozish (yangi yaratadi yoki qayta yozadi) echo "Bu matn faylga yoziladi" > chiqish.txt # Faylga qo'shish (mavjudni saqlab qoladi) echo "Bu qo'shiladi" >> chiqish.txt # Heredoc — ko'p qatorli matn yozish cat > konfiguratsiya.txt << EOF # Dastur konfiguratsiyasi app_name=MyApp version=1.0.0 debug=true port=8080 EOF # Heredoc — o'zgaruvchilar talqin qilinmaydi ('EOF' tirnoqda) cat > shablon.sh << 'EOF' #!/bin/bash echo "Bu $0 skripti" # bu yerda $0 o'zgartirilmaydi EOF ``` !!! warning "Tez-tez uchraydigan xato" `>` fayl tarkibini **o'chirib** yozadi. `>>` esa **qo'shib** yozadi. Muhim ma'lumotlar ustiga `>` bilan yozsangiz — yo'qoladi. --- ## 💻 O'zingiz sinab ko'ring — 2 Quyidagi skriptni yarating: ```bash #!/bin/bash # Fayl nomi: hisobot.sh # Ishlatish: ./hisobot.sh Ahmad 25 RED='\033[0;31m' GREEN='\033[0;32m' NC='\033[0m' if [[ $# -lt 2 ]]; then echo -e "${RED}[XATO]${NC} Argumentlar yetarli emas!" echo "Ishlatish: $0 " exit 1 fi ism=$1 yosh=$2 echo -e "${GREEN}[INFO]${NC} Foydalanuvchi: $ism" printf "%-10s: %d\n" "Yosh" $yosh if [[ $yosh -ge 18 ]]; then echo -e "${GREEN}[INFO]${NC} Voyaga yetgan" else echo -e "${RED}[WARN]${NC} Voyaga yetmagan" fi ``` Ishga tushirish: - `bash hisobot.sh Ahmad 25` — natija ko'ring - `bash hisobot.sh` — xato xabarini ko'ring --- ### Progress indikator (amaliy misol) Uzoq jarayonlarda foydalanuvchiga kutayotganini ko'rsatish: ```bash #!/bin/bash echo "Yuklanmoqda..." for i in {1..20}; do printf "█" # to'g'ri burchakli blok — progress sleep 0.1 done echo " 100%" # Foizli progress bar for i in {0..100..10}; do printf "\rJarayon: %d%% [" $i # \r — qatorni boshidan boshlab yozadi for ((j=0; j/dev/null; then echo -e "${GREEN}[OK]${NC} Internet ulanishi faol" else echo -e "${RED}[XATO]${NC} Internet ulanishi yo'q" fi # Verbose rejimda qo'shimcha ma'lumot if $VERBOSE; then echo echo -e "${YELLOW}--- Jarayonlar ---${NC}" printf "%-15s: %d\n" "Jami" "$(ps aux | wc -l)" printf "%-15s: %d\n" "Running" "$(ps aux | awk '$8=="R"' | wc -l)" fi ``` --- !!! question "Tekshirib ko'ring" Yuqoridagi skriptda `$1`, `$VERBOSE`, `VERBOSE=false` nima vazifa o'ynaydi? Agar `--verbose` o'rniga boshqa narsa kiritsangiz nima bo'ladi?
Javob — bosib oching
- `$1` — birinchi argument (masalan `--verbose`) - `VERBOSE=false` — boshlang'ich qiymat; argument berilmasa ham o'zgaruvchi mavjud - `if [[ "$1" == "--verbose" ]]` — faqat aynan `--verbose` kiritilsa `true` bo'ladi - Boshqa argument kiritsangiz (masalan `--help`) — `VERBOSE` `false` bo'lib qoladi, qo'shimcha ma'lumot chiqmaydi Bu — oddiy "feature flag" naqshi: bir skript ikki rejimda ishlaydi.
--- ## Tez-tez uchraydigan xatolar !!! warning "Tez-tez uchraydigan xato — 1: `read` dan so'ng `echo` unutish" ```bash read -s -p "Parol: " pwd # read -s parol kiritganda yangi qator qo'shmaydi # shuning uchun darrov echo kerak: echo # shundagina keyingi matn yangi qatorda boshlanadi ``` !!! warning "Tez-tez uchraydigan xato — 2: `$@` ni tirnoqsiz ishlatish" ```bash # NOTO'G'RI — bo'shliqli argumentlar bo'linib ketadi for arg in $@; do echo $arg; done # TO'G'RI — har bir argument yaxlit saqlanadi for arg in "$@"; do echo "$arg"; done ``` !!! warning "Tez-tez uchraydigan xato — 3: `>` o'rniga `>>` kerakli joyda" ```bash # Bu fayl tarkibini O'CHIRADI va qayta yozadi echo "Yangi qator" > muhim_log.txt # Bu faylga QO'SHADI — eski ma'lumot saqlanadi echo "Yangi qator" >> muhim_log.txt ``` !!! warning "Tez-tez uchraydigan xato — 4: rang kodi `NC` bilan yopilmasa" ```bash # NOTO'G'RI — keyingi barcha matn ham qizil bo'ladi echo -e "\033[0;31mXato" # TO'G'RI — rang qaytariladi echo -e "\033[0;31mXato\033[0m" # yoki o'zgaruvchi bilan: echo -e "${RED}Xato${NC}" ``` --- ## 🎒 Xulosa — eng muhimi Agar bu darsdan 5 narsani eslab qolsangiz: 1. **`read`** — foydalanuvchidan ma'lumot oladi. `-p` savolni birga qo'shadi, `-s` parol uchun, `-t` vaqt chegarasi qo'yadi. 2. **`$1 $2 $3`** — skript argumentlari. `$#` — soni, `"$@"` — barchasi (tirnoqda saqlang). 3. **`echo`** — oddiy, tez. **`printf`** — format kerak bo'lganda (jadval, raqam kengligi). 4. **Rang uchun** `\033[0;31m` + `\033[0m`. `${NC}` bilan har doim yoping. 5. **`>` o'chiradi, `>>` qo'shadi.** Log yozishda `>>` ishlatamiz. !!! success "Keyingi qadam" Endi skriptingiz foydalanuvchi bilan gaplasha oladi. Keyingi darsda **funksiyalar** — kodni qayta-qayta yozmaslik, bir marta yozib ko'p joyda ishlatish sirini o'rganasiz.