# Ma'ruza: Buyruq qobiqlari. Buyruq qobig'i tushunchasi. Qobiqlarning turlari. Bash dasturlash

## 1. Kirish

Oldingi ma'ruzalarda biz operatsion tizimlarning ichki tuzilishi, jarayonlar, oqimlar, xotira, kiritish-chiqarish va tizim chaqiruvlarini ko'rib chiqdik.

Endi foydalanuvchining operatsion tizim bilan o'zaro aloqasining eng muhim vositalaridan biri — **buyruq qobig'i (Shell)** ni ko'rib chiqamiz.

Buyruq qobig'i Linux va Unix-ga o'xshash tizimlar bilan ishlashda ayniqsa muhimdir. U keng qo'llaniladi:

* tizim administratorlari tomonidan;
* dasturchilar tomonidan;
* DevOps-muhandislar tomonidan;
* server ilovalarini ishlab chiquvchilar tomonidan;
* axborot xavfsizligi mutaxassislari tomonidan;
* ma'lumotlarni tahlil qilish mutaxassislari tomonidan;
* takrorlanuvchi amallarni avtomatlashtirishi kerak bo'lgan foydalanuvchilar tomonidan.

Buyruq qobig'i nafaqat alohida buyruqlarni bajarishga, balki murakkab amallar ketma-ketligini avtomatlashtiradigan dasturlar — **shell-skriptlar** yaratishga ham imkon beradi.

---

# 2. Buyruq qobig'i nima?

**Buyruq qobig'i (Shell)** — bu foydalanuvchiga buyruqlar orqali operatsion tizim bilan o'zaro aloqa qilish uchun interfeys taqdim etuvchi dasturiy qobiqdir.

Soddalashtirilgan holda:

```text
Foydalanuvchi
     |
     | buyruq
     v
+----------------+
|     Shell      |
+----------------+
     |
     v
Operatsion tizim
     |
     v
Apparat ta'minoti
```

Foydalanuvchi buyruqni kiritadi, qobiq uni tahlil qiladi, kerakli dasturni ishga tushiradi yoki o'rnatilgan funksiyani bajaradi.

Masalan:

```bash
ls
```

Shell bu buyruqni qabul qiladi va `ls` dasturini ishga tushiradi.

---

# 3. Shell va operatsion tizim

Shuni tushunish muhimki, **Shell operatsion tizimning o'zi emas**.

Operatsion tizim quyidagilarni o'z ichiga oladi:

* yadro;
* drayverlar;
* fayl tizimlari;
* xotira quyi tizimi;
* jarayonlarni boshqarish;
* tarmoq komponentlari;
* boshqa tizim xizmatlari.

Shell OT ustida ishlaydigan dasturdir.

Quyidagicha tasavvur qilish mumkin:

```text
+----------------------------+
|       Foydalanuvchi        |
+----------------------------+
              |
              v
+----------------------------+
|        Shell               |
| Bash | Zsh | Fish | ...    |
+----------------------------+
              |
              v
+----------------------------+
|       Kernel               |
+----------------------------+
              |
              v
+----------------------------+
|       Hardware             |
+----------------------------+
```

---

# 4. Buyruq qobig'ining asosiy funksiyalari

Buyruq qobig'i bir nechta muhim funksiyalarni bajaradi.

## 4.1. Buyruqlarni bajarish

Masalan:

```bash
pwd
```

Joriy katalogni ko'rsatadi.

```bash
ls
```

Katalog tarkibini ko'rsatadi.

```bash
mkdir projects
```

`projects` katalogini yaratadi.

---

## 4.2. Dasturlarni ishga tushirish

Shell tashqi dasturlarni ishga tushirishi mumkin.

Masalan:

```bash
python app.py
```

Bu holda Shell `python` dasturini topadi, unga `app.py` argumentini uzatadi va jarayonni ishga tushiradi.

---

## 4.3. Fayllar bilan ishlash

Shell orqali quyidagilarni amalga oshirish mumkin:

* fayllarni yaratish;
* fayllarni o'chirish;
* fayllarni nusxalash;
* fayllarni ko'chirish;
* kirish huquqlarini o'zgartirish;
* fayllarni qidirish.

Masalan:

```bash
cp file.txt backup.txt
```

Faylni nusxalaydi.

```bash
mv old.txt new.txt
```

Fayl nomini o'zgartiradi.

```bash
rm file.txt
```

Faylni o'chiradi.

---

# 5. Jarayonlar bilan ishlash

Shell jarayonlarni ishga tushirish va nazorat qilish imkonini beradi.

Masalan:

```bash
python server.py
```

Jarayonni ishga tushiradi.

Dasturni fon rejimida ishga tushirish uchun:

```bash
python server.py &
```

Ampersand `&` qobiqqa jarayon fonda bajarilishi kerakligini bildiradi.

Jarayonlarni ko'rish mumkin:

```bash
ps
```

yoki:

```bash
ps aux
```

---

# 6. Kiritish va chiqarishni yo'naltirish

Shellning eng kuchli imkoniyatlaridan biri standart oqimlarni yo'naltirishdir.

Unixda odatda quyidagilar mavjud:

```text
0 → stdin
1 → stdout
2 → stderr
```

### stdout ni yo'naltirish

```bash
ls > files.txt
```

`ls` buyrug'ining natijasi faylga yoziladi.

### Faylga qo'shish

```bash
ls >> files.txt
```

Yangi ma'lumotlar fayl oxiriga qo'shiladi.

### Xatolarni yo'naltirish

```bash
python app.py 2> errors.txt
```

Xatolar `errors.txt` ga yoziladi.

### stdout va stderr bir vaqtda

```bash
python app.py > output.txt 2> errors.txt
```

---

# 7. Konveyerlar

**Konveyer (pipe)** bir buyruq natijasini to'g'ridan-to'g'ri boshqasiga uzatish imkonini beradi.

Buning uchun quyidagi belgi ishlatiladi:

```text
|
```

Masalan:

```bash
ls | grep ".txt"
```

Avval `ls` bajariladi, so'ngra natija `grep` dasturiga uzatiladi.

Sxema:

```text
+-----+       +------+
| ls  | ----> | grep |
+-----+       +------+
```

Zanjirlar yaratish mumkin:

```bash
cat users.txt | grep "admin" | sort
```

Bu yerda:

1. `cat` faylni o'qiydi;
2. `grep` `admin` ni o'z ichiga olgan satrlarni qoldiradi;
3. `sort` natijani saralaydi.

---

# 8. Shell interpretator sifatida

Shell buyruqlar interpretatordir.

Masalan, foydalanuvchi quyidagini kiritadi:

```bash
echo "Hello"
```

Shell tahlil qiladi:

* `echo` buyrug'ini;
* `"Hello"` argumentini.

So'ngra tegishli amal bajariladi.

Tashqi dasturlar bilan ishlashda Shell odatda:

1. kiritilgan buyruqni tahlil qiladi;
2. argumentlarni ajratadi;
3. buyruq o'rnatilgan ekanligini aniqlaydi;
4. kerak bo'lganda bajariladigan faylni qidiradi;
5. jarayon yaratadi;
6. unga argumentlarni uzatadi;
7. tugashini kutadi yoki fon rejimida ishlashda ishni davom ettiradi.

---

# 9. Interaktiv qobiq

Foydalanuvchi terminalni ochganda, odatda interaktiv Shell ishga tushiriladi.

Masalan:

```text
user@computer:~$
```

Bu yerda:

* `user` — foydalanuvchi nomi;
* `computer` — kompyuter nomi;
* `~` — uy katalogi;
* `$` — oddiy foydalanuvchi uchun taklif belgisi.

Unix-ga o'xshash tizimlarda root uchun ko'pincha quyidagi ishlatiladi:

```text
root@computer:~#
```

---

# 10. Buyruq qobiqlarining turlari

Ko'plab qobiqlar mavjud.

Eng mashhur qobiqlar:

* sh;
* Bash;
* Zsh;
* Ksh;
* Fish;
* Csh;
* Tcsh;
* PowerShell;
* Command Prompt (cmd.exe).

---

# 11. Bourne Shell — sh

**sh** — tarixiy jihatdan eng muhim Unix qobiqlaridan biri.

U Unix va Bourne shell oilasi bilan bog'liq.

`sh` qobig'i shell scripting ning keyingi rivojlanishiga katta ta'sir ko'rsatdi.

Bugungi kunda `sh` ko'pincha maksimal darajada ko'chma shell-skriptlarni ishga tushirish uchun ishlatiladi.

Masalan:

```sh
#!/bin/sh

echo "Hello, World!"
```

Asosiy ustunligi — soddalik va yuqori ko'chmalik.

---

# 12. Bash

**Bash (Bourne Again SHell)** — Unix/Linux ning eng mashhur buyruq qobiqlaridan biri.

Bash Bourne shell ning mos keladigan va kengaytirilgan o'rnini bosuvchi sifatida ishlab chiqilgan.

Bash quyidagilarda ishlatiladi:

* Linuxda;
* macOSda;
* serverlarda;
* Docker-konteynerlarda;
* CI/CDda;
* DevOpsda;
* tizim boshqarishda.

Joriy qobiqni tekshirish mumkin:

```bash
echo $SHELL
```

---

# 13. Bash imkoniyatlari

Bash quyidagilarni taqdim etadi:

* buyruqlarni bajarish;
* o'zgaruvchilar;
* shartlar;
* sikllar;
* funksiyalar;
* massivlar;
* buyruq satri argumentlari;
* kiritish-chiqarishni yo'naltirish;
* konveyerlar;
* buyruq almashtirishlari;
* jarayonlar bilan ishlash;
* avtomatlashtirish.

Shunday qilib, Bash nafaqat qobiq, balki avtomatlashtirish ssenariylarini yaratish uchun to'laqonli muhitdir.

---

# 14. Zsh

**Zsh (Z Shell)** — Unixning kuchli interaktiv qobig'i.

U kengaytirilgan imkoniyatlarni taqdim etadi:

* avtoto'ldirish;
* yaxshilangan tarix;
* kuchli sozlash;
* glob kengaytmalari;
* parametrlar bilan qulay ishlash;
* plaginlar va mavzular.

Zsh ayniqsa dasturchilar orasida mashhur.

Masalan, ko'plab macOS foydalanuvchilari Zsh ni standart qobiq sifatida ishlatishadi.

---

# 15. Fish

**Fish (Friendly Interactive SHell)** birinchi navbatda interaktiv ishlash qulayligiga yo'naltirilgan.

Xususiyatlari:

* intellektual avtoto'ldirish;
* sintaksis yoritilishi;
* qulay buyruqlar tarixi;
* oddiy foydalanuvchi interfeysi.

Biroq Fish Bash bilan to'liq moslikka ataylab intilmaydi.

Shuning uchun Bash skriptlarini avtomatik ravishda Fish bilan mos deb hisoblash mumkin emas.

---

# 16. Ksh

**KornShell (ksh)** — Devid Korn tomonidan ishlab chiqilgan qobiq.

U Unix-shell rivojlanishiga katta ta'sir ko'rsatdi.

Ksh quyidagilarni qo'llab-quvvatlaydi:

* o'zgaruvchilar;
* funksiyalar;
* shartlar;
* sikllar;
* jarayonlarni boshqarish;
* buyruqlar tarixi.

Kshning ba'zi imkoniyatlari keyinchalik Bash va boshqa qobiqlarda o'z aksini topdi.

---

# 17. Csh va Tcsh

`csh` — sintaksisi qisman C tiliga o'xshash qobiq.

`tcsh` — `csh` ning kengaytirilgan versiyasi.

Ular tarixiy jihatdan Unix tizimlarida ishlatilgan, ammo bugungi kunda ko'chma shell-skriptlar yozish uchun ko'pincha `sh` yoki Bash ishlatiladi.

---

# 18. PowerShell

**PowerShell** — Microsoftning buyruq qobig'i va ssenariy tili.

U an'anaviy Unix Shelldan sezilarli darajada farq qiladi.

Masalan:

```powershell
Get-Process
```

jarayonlar haqida ma'lumot oladi.

PowerShellda buyruqlar ko'pincha **cmdletlar** deb ataladi.

Misollar:

```powershell
Get-ChildItem
Get-Service
Get-Process
Get-ComputerInfo
```

PowerShellning muhim farqlaridan biri — konveyer nafaqat matn, balki tuzilgan obyektlarni uzatishi mumkin.

---

# 19. Command Prompt

**Command Prompt (cmd.exe)** — Windowsning klassik buyruq qobig'i.

Buyruq misollari:

```cmd
dir
cd
mkdir
copy
del
```

U zamonaviy PowerShell bilan solishtirganda ssenariy imkoniyatlari cheklangan.

Biroq `cmd.exe` hanuzgacha moslik va batch-fayllarni bajarish uchun ishlatiladi.

---

# 20. Mashhur qobiqlarni solishtirish

| Qobiq       | Asosiy muhit          | Xususiyatlari                            |
| ----------- | --------------------- | ---------------------------------------- |
| sh          | Unix/Linux            | Soddalik, ko'chmalik                     |
| Bash        | Linux/Unix            | Keng imkoniyatlar, mashhurlik            |
| Zsh         | Unix/macOS/Linux      | Qulay interaktiv ishlash                 |
| Fish        | Unix/Linux/macOS      | Qulay interaktiv interfeys               |
| Ksh         | Unix                  | Tarixiy ahamiyat, kuchli scripting       |
| Csh/Tcsh    | Unix                  | C ga yaqin sintaksis                     |
| PowerShell  | Windows/Linux/macOS   | Obyektli pipeline                        |
| cmd.exe     | Windows               | Soddalik va moslik                       |

---

# 21. Joriy qobiqni qanday aniqlash mumkin

Linuxda quyidagini bajarish mumkin:

```bash
echo $SHELL
```

Masalan:

```text
/bin/bash
```

O'zgaruvchini ham ko'rish mumkin:

```bash
echo $0
```

Yoki:

```bash
ps -p $$ -o comm=
```

---

# 22. Bash-skript nima?

**Bash-skript** — Bash buyruqlari ketma-ketligini o'z ichiga olgan matnli fayl.

Masalan:

```bash
#!/bin/bash

echo "Hello, World!"
```

Odatda fayl quyidagi kengaytmaga ega bo'ladi:

```text
.sh
```

Masalan:

```text
backup.sh
```

`.sh` kengaytmasi majburiy emas. Faylning tarkibi va bajarish huquqlari muhimroq.

---

# 23. Shebang

Skriptning birinchi satri ko'pincha quyidagicha ko'rinadi:

```bash
#!/bin/bash
```

Bu **shebang** deb ataladi.

U tizimga faylni bajarish uchun qaysi interpretatordan foydalanish kerakligini bildiradi.

Masalan:

```bash
#!/bin/bash
```

Bash dan foydalanadi.

Quyidagini ishlatish mumkin:

```bash
#!/bin/sh
```

yoki:

```bash
#!/usr/bin/env bash
```

Oxirgi variant `PATH` muhit o'zgaruvchisi orqali Bash ni qidiradi.

---

# 24. Birinchi Bash-skript

Fayl yaratamiz:

```text
hello.sh
```

Tarkibi:

```bash
#!/bin/bash

echo "Hello, World!"
```

Faylni bajariladigan qilamiz:

```bash
chmod +x hello.sh
```

Ishga tushiramiz:

```bash
./hello.sh
```

Natija:

```text
Hello, World!
```

---

# 25. echo buyrug'i

`echo` buyrug'i matn chiqarish uchun ishlatiladi.

```bash
echo "Hello"
```

Bir nechta satr chiqarish mumkin:

```bash
echo "Name: Ahmad"
echo "Age: 30"
```

O'zgaruvchilar qiymatini chiqarish mumkin:

```bash
name="Ahmad"
echo "Hello, $name"
```

Natija:

```text
Hello, Ahmad
```

---

# 26. Bash o'zgaruvchilari

Bashda o'zgaruvchilar turini ko'rsatmasdan yaratiladi:

```bash
name="Ahmad"
age=30
```

Muhim:

```bash
name="Ahmad"
```

emas:

```bash
name = "Ahmad"
```

Oddiy tayinlashda `=` atrofida bo'shliqlar ruxsat etilmaydi.

Qiymatni olish:

```bash
echo "$name"
```

Misol:

```bash
#!/bin/bash

name="Ahmad"
age=30

echo "Name: $name"
echo "Age: $age"
```

---

# 27. Yakka va juft qo'shtirnoqlar

Bash quyidagilarni farqlaydi:

```bash
'text'
```

va:

```bash
"text"
```

Juft qo'shtirnoqlarda o'zgaruvchi almashtiriladi:

```bash
name="Ahmad"
echo "Hello $name"
```

Natija:

```text
Hello Ahmad
```

Yakka qo'shtirnoqlarda o'zgaruvchi odatda ochilmaydi:

```bash
echo 'Hello $name'
```

Natija:

```text
Hello $name
```

---

# 28. Maxsus o'zgaruvchilar

Bash maxsus o'zgaruvchilarni taqdim etadi.

### `$0`

Skript nomi.

### `$1`, `$2`, ...

Buyruq satri argumentlari.

### `$#`

Argumentlar soni.

### `$?`

Oxirgi buyruqning qaytish kodi.

### `$$`

Joriy Shell jarayonining PID si.

### `$HOME`

Foydalanuvchining uy katalogi.

### `$USER`

Foydalanuvchi nomi.

Misol:

```bash
echo "Script: $0"
echo "PID: $$"
echo "User: $USER"
```

---

# 29. Buyruq satri argumentlari

Qaraylik:

```bash
#!/bin/bash

echo "Hello, $1"
```

Ishga tushirish:

```bash
./hello.sh Ahmad
```

Natija:

```text
Hello, Ahmad
```

Bu yerda:

```text
$1 = Ahmad
```

Agar quyidagini bajarsak:

```bash
./hello.sh Ahmad Tashkent
```

u holda:

```text
$1 = Ahmad
$2 = Tashkent
```

---

# 30. Argumentlar sonini tekshirish

`$#` dan foydalanish mumkin.

```bash
#!/bin/bash

if [ "$#" -ne 1 ]; then
    echo "Usage: $0 <name>"
    exit 1
fi

echo "Hello, $1"
```

Bu yerda foydalanuvchi aynan bitta argument uzatganligi tekshiriladi.

---

# 31. if shartlari

Asosiy sintaksis:

```bash
if shart; then
    buyruqlar
elif boshqa_shart; then
    buyruqlar
else
    buyruqlar
fi
```

Misol:

```bash
#!/bin/bash

age=20

if [ "$age" -ge 18 ]; then
    echo "Adult"
else
    echo "Minor"
fi
```

---

# 32. Solishtirish operatorlari

Sonlar uchun:

```text
-eq   teng
-ne   teng emas
-gt   katta
-ge   katta yoki teng
-lt   kichik
-le   kichik yoki teng
```

Misol:

```bash
if [ "$age" -ge 18 ]; then
    echo "Adult"
fi
```

---

# 33. Satrlarni solishtirish

Quyidagilar ishlatiladi:

```text
=       satrlar teng
!=      satrlar teng emas
-z      satr bo'sh
-n      satr bo'sh emas
```

Misol:

```bash
name="Ahmad"

if [ -n "$name" ]; then
    echo "Name is not empty"
fi
```

---

# 34. Fayllarni tekshirish

Bash fayl xossalarini tekshirish imkonini beradi.

Asosiy operatorlar:

```text
-e   mavjud
-f   oddiy fayl
-d   katalog
-r   o'qish uchun mavjud
-w   yozish uchun mavjud
-x   bajarish uchun mavjud
```

Misol:

```bash
if [ -f "data.txt" ]; then
    echo "File exists"
else
    echo "File not found"
fi
```

---

# 35. for sikli

Misol:

```bash
for name in Ahmad Ali Sara; do
    echo "Hello, $name"
done
```

Natija:

```text
Hello, Ahmad
Hello, Ali
Hello, Sara
```

Fayllarni qayta ishlash uchun sikldan foydalanish mumkin:

```bash
for file in *.txt; do
    echo "$file"
done
```

---

# 36. while sikli

Misol:

```bash
counter=1

while [ "$counter" -le 5 ]; do
    echo "$counter"
    counter=$((counter + 1))
done
```

Natija:

```text
1
2
3
4
5
```

---

# 37. until sikli

`until` shart yolg'on bo'lgunga qadar siklni bajaradi.

```bash
counter=1

until [ "$counter" -gt 5 ]; do
    echo "$counter"
    counter=$((counter + 1))
done
```

---

# 38. Arifmetik amallar

Bashda arifmetik ifodalar ishlatiladi.

Masalan:

```bash
a=10
b=5

sum=$((a + b))
difference=$((a - b))
product=$((a * b))
division=$((a / b))

echo "$sum"
echo "$difference"
echo "$product"
echo "$division"
```

---

# 39. Funksiyalar

Bash funksiyalarni aniqlash imkonini beradi.

```bash
greet() {
    echo "Hello, $1"
}

greet "Ahmad"
```

Funksiya tugash kodini qaytarishi mumkin:

```bash
check_file() {
    if [ -f "$1" ]; then
        return 0
    else
        return 1
    fi
}
```

Foydalanish:

```bash
if check_file "data.txt"; then
    echo "File exists"
fi
```

---

# 40. Tugash kodi

Har bir buyruq odatda biror kod bilan tugaydi.

Qiymat:

```text
0
```

odatda muvaffaqiyatli bajarilishni anglatadi.

Noldan farqli qiymat odatda xato yoki maxsus holatni anglatadi.

Masalan:

```bash
ls /tmp
echo $?
```

Agar buyruq muvaffaqiyatli bajarilgan bo'lsa:

```text
0
```

---

# 41. exit buyrug'i

Skriptni tugatish uchun quyidagi ishlatiladi:

```bash
exit 0
```

Masalan:

```bash
if [ ! -f "config.txt" ]; then
    echo "Configuration not found"
    exit 1
fi
```

Bu yerda `1` xato kodi sifatida ishlatiladi.

---

# 42. Buyruq almashtirishlari

Bash bir buyruq natijasini boshqasining ichida ishlatishga imkon beradi.

Eski sintaksis:

```bash
date=`date`
```

Zamonaviy va tavsiya etilgan sintaksis:

```bash
today=$(date)
```

Masalan:

```bash
echo "Today: $(date)"
```

Fayllar sonini olish mumkin:

```bash
count=$(find . -type f | wc -l)

echo "Files: $count"
```

---

# 43. O'zgaruvchi almashtirishlari

Asosiy sintaksis:

```bash
"$variable"
```

yoki:

```bash
"${variable}"
```

`${variable}` shakli o'zgaruvchi nomi matn bilan yonma-yon turganida ayniqsa foydali.

Masalan:

```bash
name="Ahmad"

echo "${name}_backup"
```

Natija:

```text
Ahmad_backup
```

---

# 44. Massivlar

Bash indekslangan massivlarni qo'llab-quvvatlaydi.

```bash
colors=("red" "green" "blue")
```

Element olish:

```bash
echo "${colors[0]}"
```

Elementlar soni:

```bash
echo "${#colors[@]}"
```

Aylanib chiqish:

```bash
for color in "${colors[@]}"; do
    echo "$color"
done
```

---

# 45. Fayllar bilan ishlash

Fayl yaratish:

```bash
touch data.txt
```

Yozish:

```bash
echo "Hello" > data.txt
```

Qo'shish:

```bash
echo "World" >> data.txt
```

O'qish:

```bash
cat data.txt
```

O'chirish:

```bash
rm data.txt
```

---

# 46. Fayllarni qidirish

Qidirish uchun `find` ishlatiladi.

Masalan:

```bash
find . -name "*.txt"
```

Barcha Python fayllarini topish:

```bash
find . -name "*.py"
```

100 MB dan katta fayllarni topish:

```bash
find . -type f -size +100M
```

---

# 47. Matn qidirish

`grep` buyrug'i matn qidirish imkonini beradi.

Masalan:

```bash
grep "error" application.log
```

Registrni e'tiborsiz qoldirish:

```bash
grep -i "error" application.log
```

Rekursiv qidirish:

```bash
grep -r "TODO" .
```

---

# 48. find va grep birgalikda

Juda keng tarqalgan misol:

```bash
find . -name "*.log" -exec grep -H "ERROR" {} \;
```

Buyruq `.log` fayllarini topadi va ularning tarkibini tekshiradi.

---

# 49. Bashda yo'naltirish va pipeline

Qaraylik:

```bash
cat access.log | grep "404" | wc -l
```

Bu yerda:

```text
cat
 |
 v
grep
 |
 v
wc
```

Quyidagicha o'qish mumkin:

> Logda `404` ni o'z ichiga olgan satrlar sonini hisoblash.

---

# 50. Standart xato

stderrni yo'naltirish mumkin:

```bash
command 2> errors.log
```

stdout va stderrni birlashtirish:

```bash
command > output.log 2>&1
```

Bashda qisqartirilgan shakl ham mavjud:

```bash
command &> output.log
```

---

# 51. Shartli buyruq bajarish

Quyidagilardan foydalanish mumkin:

```bash
&&
```

va:

```bash
||
```

### `&&`

Keyingi buyruq faqat oldingi muvaffaqiyatli bo'lganda bajariladi:

```bash
mkdir backup && echo "Backup directory created"
```

### `||`

Keyingi buyruq oldingi xato bo'lganda bajariladi:

```bash
mkdir backup || echo "Could not create directory"
```

Kombinatsiya qilish mumkin:

```bash
command1 && command2 || command3
```

---

# 52. Izohlar

Izohlar `#` belgisi bilan boshlanadi.

```bash
#!/bin/bash

# This is a comment

echo "Hello"
```

Murakkab skriptlar uchun izohlar ayniqsa muhim.

---

# 53. Oddiy zaxira nusxalash skripti misoli

Amaliy misolni ko'rib chiqamiz.

```bash
#!/bin/bash

SOURCE="$HOME/Documents"
BACKUP="$HOME/backup"

mkdir -p "$BACKUP"

cp -r "$SOURCE" "$BACKUP"

echo "Backup completed."
```

Bu yerda:

1. manba katalogi belgilanadi;
2. zaxira nusxa katalogi belgilanadi;
3. katalog yaratiladi;
4. fayllar nusxalanadi;
5. xabar chiqariladi.

---

# 54. Zaxira nusxalashning yaxshilangan varianti

Sana qo'shish mumkin:

```bash
#!/bin/bash

SOURCE="$HOME/Documents"
DATE=$(date +%Y-%m-%d_%H-%M-%S)
BACKUP="$HOME/backup_$DATE"

mkdir -p "$BACKUP"

cp -r "$SOURCE" "$BACKUP"

echo "Backup created:"
echo "$BACKUP"
```

Endi har bir ishga tushirish alohida nusxa yaratadi.

---

# 55. Xatolarni tekshirish

Yaxshi skript operatsiyalar natijalarini tekshirishi kerak.

Masalan:

```bash
#!/bin/bash

SOURCE="$HOME/Documents"
BACKUP="$HOME/backup"

if [ ! -d "$SOURCE" ]; then
    echo "Source directory does not exist."
    exit 1
fi

mkdir -p "$BACKUP"

if cp -r "$SOURCE" "$BACKUP"; then
    echo "Backup completed successfully."
else
    echo "Backup failed."
    exit 1
fi
```

---

# 56. Bashda set parametrlari

Ishonchliroq skriptlar uchun ko'pincha quyidagi ishlatiladi:

```bash
set -e
```

U buyruq xatosida skriptni tugatadi.

Quyidagini ishlatish mumkin:

```bash
set -u
```

mavjud bo'lmagan o'zgaruvchilarga murojaat qilishni xato sifatida qayta ishlash uchun.

Ko'pincha quyidagi qo'llaniladi:

```bash
set -euo pipefail
```

Bu ba'zi xatolarni ertaroq aniqlashga yordam beradi.

Biroq, har bir parametrning xususiyatlarini tushunish va skriptlarni sinash muhim — bu barcha xatolardan universal himoya emas.

---

# 57. `set -x`

Nosozliklarni tuzatishda quyidagini ishlatish mumkin:

```bash
set -x
```

Shundan so'ng Bash bajariladigan buyruqlarni chiqaradi.

Masalan:

```bash
#!/bin/bash

set -x

name="Ahmad"
echo "Hello $name"
```

Bu skript nima bajarayotganini tushunishga yordam beradi.

---

# 58. Foydalanuvchi kiritishini o'qish

Foydalanuvchidan qiymat olish uchun `read` ishlatiladi.

```bash
#!/bin/bash

echo "Enter your name:"
read name

echo "Hello, $name"
```

Ixchamroq yozish mumkin:

```bash
read -p "Enter your name: " name
echo "Hello, $name"
```

---

# 59. Bashda menyu

Bash interaktiv menyular yaratish uchun ishlatilishi mumkin.

Masalan:

```bash
#!/bin/bash

echo "1. Show date"
echo "2. Show current directory"
echo "3. Show files"

read -p "Choose: " choice

case "$choice" in
    1)
        date
        ;;
    2)
        pwd
        ;;
    3)
        ls
        ;;
    *)
        echo "Unknown option"
        ;;
esac
```

---

# 60. case konstruktsiyasi

`case` bir nechta variant bo'lishi mumkin bo'lganda qulay.

Sintaksis:

```bash
case "$variable" in
    value1)
        commands
        ;;
    value2)
        commands
        ;;
    *)
        default_commands
        ;;
esac
```

Misol:

```bash
case "$1" in
    start)
        echo "Starting..."
        ;;
    stop)
        echo "Stopping..."
        ;;
    restart)
        echo "Restarting..."
        ;;
    *)
        echo "Usage: $0 {start|stop|restart}"
        exit 1
        ;;
esac
```

---

# 61. Satrlar bilan ishlash

Bash satrlar bilan ko'plab amallarni taqdim etadi.

Masalan:

```bash
text="Hello World"

echo "${#text}"
```

Satr uzunligini qaytaradi.

Matnning bir qismini almashtirish mumkin:

```bash
echo "${text/World/Bash}"
```

Natija:

```text
Hello Bash
```

---

# 62. Qo'shtirnoqlar va xavfsizlik

Bashning juda muhim qoidasi:

> Yo'llar yoki foydalanuvchi ma'lumotlarini o'z ichiga olgan o'zgaruvchilarni odatda juft qo'shtirnoqlarga joylashtirish kerak.

Yaxshisi:

```bash
rm -- "$file"
```

quyidagidan ko'ra:

```bash
rm $file
```

Nima uchun?

Chunki yo'lda bo'shliqlar bo'lishi mumkin.

Masalan:

```text
My Documents/file.txt
```

Qo'shtirnoqlarsiz Shell buni bir nechta alohida argument sifatida qabul qilishi mumkin.

---

# 63. `rm -rf` xavfi

Buyruq:

```bash
rm -rf
```

oddiy tiklash imkoniyatisiz ko'p miqdordagi fayllarni o'chirishi mumkin.

Shuning uchun fayllarni o'chirishni ishlatadigan avtomatik skriptlarni ayniqsa ehtiyotkorlik bilan yozish kerak.

Hech qachon tekshirmasdan quyidagi kabi konstruktsiyalarni ishlatmaslik kerak:

```bash
rm -rf "$VARIABLE"/*
```

agar o'zgaruvchining qiymati bo'sh yoki kutilmagan bo'lishi mumkin bo'lsa.

---

# 64. PATH

`PATH` muhit o'zgaruvchisi Shell bajariladigan dasturlarni qidiradigan kataloglar ro'yxatini o'z ichiga oladi.

Ko'rish:

```bash
echo "$PATH"
```

Masalan:

```text
/usr/local/bin:/usr/bin:/bin
```

Foydalanuvchi quyidagini kiritganda:

```bash
python
```

Shell `PATH` dagi kataloglarda tegishli bajariladigan faylni qidiradi.

Joylashuvini aniqlash:

```bash
which python
```

yoki:

```bash
command -v python
```

Skriptlarda `command -v` dan foydalanish afzalroq, chunki bu Shell ning o'rnatilgan mexanizmi.

---

# 65. Muhit o'zgaruvchilari

Shell muhit o'zgaruvchilar to'plamiga ega.

Masalan:

```bash
echo "$HOME"
echo "$USER"
echo "$PATH"
echo "$SHELL"
```

Muhit o'zgaruvchisi yaratish mumkin:

```bash
export APP_ENV=production
```

Shundan so'ng bolalar jarayonlari uning qiymatini olishi mumkin.

---

# 66. Mahalliy o'zgaruvchilar va muhit o'zgaruvchilari

```bash
name="Ahmad"
```

joriy shell-jarayonining oddiy o'zgaruvchisini yaratadi.

```bash
export name
```

uni bolalar jarayonlariga ochiq qiladi.

Masalan:

```bash
export APP_ENV=production
python app.py
```

Python dasturi quyidagini olishi mumkin:

```python
import os

print(os.environ["APP_ENV"])
```

---

# 67. Pastki qobiqlar

Shell bolalar Shell-jarayonlarini yaratishi mumkin.

Masalan:

```bash
(
    cd /tmp
    echo "Inside subshell"
)
```

Pastki qobiq ichida katalogni o'zgartirish ota qobiqning joriy katalogini o'zgartirmaydi.

---

# 68. Skriptlar va jarayonlar

Shuni tushunish muhim:

```text
Terminal
   |
   v
Shell
   |
   +---- script.sh
            |
            +---- command 1
            |
            +---- command 2
            |
            +---- command 3
```

Shell-skript ko'plab jarayonlarni ishga tushirishi mumkin.

Shunday qilib, Bash dasturlash quyidagi mavzular bilan chambarchas bog'liq:

* jarayonlar;
* oqimlar;
* fayl tizimi;
* kiritish-chiqarish;
* kirish huquqlari;
* muhit o'zgaruvchilari.

---

# 69. Amaliy misol: diskni monitoring qilish

Kichik skriptni ko'rib chiqamiz:

```bash
#!/bin/bash

usage=$(df -h / | awk 'NR==2 {print $5}' | tr -d '%')

echo "Disk usage: $usage%"

if [ "$usage" -ge 80 ]; then
    echo "WARNING: Disk usage is high!"
else
    echo "Disk usage is normal."
fi
```

Bu yerda bir nechta vosita bir vaqtda ishlatiladi:

* `df` — disklar haqida ma'lumot;
* `awk` — matnni qayta ishlash;
* `tr` — belgilarni o'chirish;
* o'zgaruvchi;
* `if` sharti.

Bu Unix tamoyilining yaxshi namunasi:

> oddiy dasturlar zanjirga birlashtiriladi va murakkabroq masalani hal qiladi.

---

# 70. Amaliy misol: katta fayllarni qidirish

```bash
#!/bin/bash

DIRECTORY="${1:-.}"

find "$DIRECTORY" -type f -size +100M -print
```

Ishga tushirish:

```bash
./large_files.sh /home/user
```

Agar argument ko'rsatilmasa:

```bash
./large_files.sh
```

joriy katalog ishlatiladi.

Konstruktsiya:

```bash
${1:-.}
```

quyidagini anglatadi:

> `$1` dan foydalanish, agar u mavjud bo'lmasa yoki bo'sh bo'lsa, `.` dan foydalanish.

---

# 71. Amaliy misol: oddiy tizim monitori

```bash
#!/bin/bash

echo "===== SYSTEM INFO ====="

echo "Hostname:"
hostname

echo
echo "Current user:"
whoami

echo
echo "Current directory:"
pwd

echo
echo "Disk usage:"
df -h /

echo
echo "Memory:"
free -h

echo
echo "Uptime:"
uptime
```

Bu skript tizim haqida asosiy ma'lumotlarni yig'adi.

---

# 72. Amaliy misol: zaxira nusxalashni avtomatlashtirish

To'liqroq ssenariy qurilishi mumkin:

```bash
#!/bin/bash

set -euo pipefail

SOURCE="$HOME/projects"
BACKUP_DIR="$HOME/backups"
DATE=$(date +%Y-%m-%d_%H-%M-%S)
BACKUP_FILE="$BACKUP_DIR/projects_$DATE.tar.gz"

mkdir -p "$BACKUP_DIR"

tar -czf "$BACKUP_FILE" "$SOURCE"

echo "Backup created:"
echo "$BACKUP_FILE"
```

Bu yerda quyidagilar ishlatiladi:

* `set -euo pipefail`;
* o'zgaruvchilar;
* `date`;
* katalog yaratish;
* `tar` orqali arxivlash;
* yo'llarni qayta ishlash.

---

# 73. Skriptlarni bajarilishini rejalashtirish

Shell-skriptlar vazifa rejalashtirgichlar bilan birgalikda ayniqsa foydali.

Linuxda **cron** keng qo'llaniladi.

Masalan, vazifa har kuni zaxira nusxalashni ishga tushirishi mumkin.

Cron quyidagilarni avtomatlashtirishga imkon beradi:

* zaxira nusxalash;
* eski fayllarni tozalash;
* hisobotlarni ishga tushirish;
* ma'lumotlarni sinxronlashtirish;
* monitoring;
* serverlarni xizmat ko'rsatish.

---

# 74. DevOpsda Bash

Bash DevOpsning muhim vositasi.

U quyidagilar uchun ishlatiladi:

* dasturlarni o'rnatish;
* serverlarni sozlash;
* Dockerni ishga tushirish;
* Git bilan ishlash;
* CI/CD;
* fayllarni boshqarish;
* monitoring;
* avtomatik joylashtirish.

Masalan:

```bash
git pull
npm install
npm run build
systemctl restart myapp
```

Bularning barchasini bitta joylashtirish skriptida birlashtirish mumkin.

---

# 75. Bash va Docker

Bash ko'pincha Docker-konteynerlar ichida ishlatiladi.

Masalan:

```dockerfile
CMD ["bash", "start.sh"]
```

yoki:

```bash
docker exec container_name bash
```

Shell konteyner ichida ma'muriy amallarni bajarishga imkon beradi.

---

# 76. Bash va Git

Git ham Shell dan faol ishlatiladi:

```bash
git status
git add .
git commit -m "Update"
git push
```

Takrorlanuvchi Git-amallarni Bash-skript yordamida avtomatlashtirish mumkin.

Masalan:

```bash
#!/bin/bash

git add .
git commit -m "Automatic backup"
git push
```

---

# 77. Bashning afzalliklari

Bashning asosiy afzalliklari:

1. Keng tarqalganligi.
2. Avtomatlashtirishning qulayligi.
3. Unix/Linux bilan integratsiya.
4. Standart utilitalarning juda ko'pligi.
5. Dasturlarni ishga tushirishning soddaligi.
6. Fayllar bilan qulay ishlash.
7. Konveyerlar va yo'naltirishlar.
8. Tizim boshqarishi bilan yaxshi integratsiya.

---

# 78. Bashning cheklovlari

Bash universal dasturlash tili emas.

Murakkab loyihalar uchun quyidagilarni ishlatish yaxshiroq:

* Python;
* Go;
* Java;
* C++;
* Rust;
* JavaScript/TypeScript.

Bash ayniqsa quyidagilar uchun yaxshi:

* avtomatlashtirish;
* tizim boshqarishi;
* fayllar bilan ishlash;
* dasturlarni ishga tushirish;
* CLI-vositalarni birlashtirish.

Lekin murakkab mantiq ko'p bo'lgan katta ilovalarni Bashda qo'llab-quvvatlash qiyin.

---

# 79. Qachon Bash, qachon Python ishlatish kerak?

### Bash yaxshi mos keladi:

```text
Bir nechta buyruq ishga tushirish
       ↓
Fayllarni qayta ishlash
       ↓
Shartni tekshirish
       ↓
Boshqa dasturni ishga tushirish
       ↓
Natijani saqlash
```

### Python yaxshiroq mos keladi:

```text
Murakkab biznes-mantiq
       ↓
Sinflar
       ↓
Ko'p miqdordagi ma'lumotlar
       ↓
API
       ↓
Ma'lumotlar bazalari
       ↓
Testlash
       ↓
Katta ilova
```

Amaliy qoida:

> Agar asosiy vazifa boshqa dasturlar va tizim buyruqlarini boshqarishdan iborat bo'lsa, Bash ko'pincha yaxshi tanlov. Agar asosiy vazifa murakkab ma'lumotlarni qayta ishlash yoki biznes-mantiq bo'lsa, Python yoki boshqa to'laqonli dasturlash tilini tanlash yaxshiroq.

---

# 80. Yangi boshlovchilarning tipik xatolari

### Xato 1. `=` atrofida bo'shliqlar

Noto'g'ri:

```bash
name = "Ahmad"
```

To'g'ri:

```bash
name="Ahmad"
```

### Xato 2. Qo'shtirnoqlar yo'qligi

Potentsial xavfli:

```bash
rm $file
```

Yaxshisi:

```bash
rm -- "$file"
```

### Xato 3. Qaytish kodlarini e'tiborsiz qoldirish

Yomon:

```bash
cp file.txt backup/
echo "Done"
```

Agar `cp` xato bilan tugasa, skript baribir `Done` deb xabar beradi.

### Xato 4. Juda murakkab Bash

Agar skript ko'p mantiqli katta loyihaga aylansa, Python ni ko'rib chiqish yaxshiroq.

### Xato 5. Xavfli buyruqlarni tekshirmasdan bajarish

Ayniqsa quyidagilar bilan ehtiyotkor bo'lish kerak:

```bash
rm
chmod
chown
mv
```

---

# 81. Bash-skriptlarni nosozliklarini tuzatish

Sintaksisni tekshirish uchun quyidagini ishlatish mumkin:

```bash
bash -n script.sh
```

Kuzatish uchun:

```bash
bash -x script.sh
```

Quyidagini ishlatish mumkin:

```bash
shellcheck script.sh
```

ShellCheck — Bash/Shell-skriptlarning mashhur statik tahlilchisi bo'lib, potentsial xatolar va tipik muammolarni topishga yordam beradi.

---

# 82. Bash-skriptlarni yozish bo'yicha tavsiyalar

Yaxshi skript quyidagilarga ega bo'lishi kerak:

* tushunarli o'zgaruvchi nomlari;
* kirish ma'lumotlarini tekshirish;
* xatolarni qayta ishlash;
* o'zgaruvchilar atrofida qo'shtirnoqlar ishlatish;
* zaruratsiz xavfli amallarni bajarmash;
* izohlar bilan hujjatlashtirish;
* tushunarli tugash kodi;
* iloji boricha sodda bo'lish;
* imkon qadar ShellCheck statik tekshiruvidan o'tish.

---

# 83. Shell ish sxemasining yakuniy ko'rinishi

Buyruq bajarilishining to'liq yo'lini quyidagicha tasavvur qilish mumkin:

```text
Foydalanuvchi kiritadi:
       ls -la /home
             |
             v
        +---------+
        |  Bash   |
        +---------+
             |
       Buyruq tahlili
             |
             v
       Dasturni qidirish
             |
             v
       Jarayon yaratish
             |
             v
      Tizim chaqiruvlari
             |
             v
          Kernel
             |
             v
        File System
             |
             v
          Disk
             |
             v
        Natija
             |
             v
           Bash
             |
             v
        Terminal
```

---

# 84. Nazorat savollari

1. Buyruq qobig'i nima?
2. Shell operatsion tizim yadrosidan nimasi bilan farq qiladi?
3. Buyruq qobig'i qanday funksiyalarni bajaradi?
4. Buyruqlar interpretatori nima?
5. Asosiy buyruq qobiqlarini nomlang.
6. `sh` nima?
7. Bash nima?
8. Bash Zshdan nimasi bilan farq qiladi?
9. Fish qanday xususiyatlarga ega?
10. PowerShell nima?
11. `cmd.exe` nima uchun ishlatiladi?
12. Bash-skript nima?
13. Shebang nima?
14. `#!/bin/bash` nima uchun ishlatiladi?
15. Bajariladigan Bash-skriptni qanday yaratish mumkin?
16. Bash o'zgaruvchisi nima?
17. Buyruq satri argumentlari qanday uzatiladi?
18. `$1` nimani bildiradi?
19. `$#` nimani bildiradi?
20. `$?` nimani bildiradi?
21. Jarayonning qaytish kodi nima?
22. `if` nima uchun ishlatiladi?
23. `case` nima uchun ishlatiladi?
24. `for` `while` dan nimasi bilan farq qiladi?
25. Bash funksiyasi nima?
26. Pipeline nima?
27. `>` nima uchun ishlatiladi?
28. `>` `>>` dan nimasi bilan farq qiladi?
29. `stdin`, `stdout`, `stderr` nima?
30. Buyruq almashtirishlari nima?
31. Muhit o'zgaruvchisi nima?
32. `export` nima uchun ishlatiladi?
33. `PATH` nima?
34. `find` nima uchun ishlatiladi?
35. `grep` nima uchun ishlatiladi?
36. `cron` nima?
37. O'zgaruvchilarni nima uchun qo'shtirnoqlarga joylashtirish kerak?
38. `set -euo pipefail` nima uchun ishlatiladi?
39. ShellCheck nima uchun ishlatiladi?
40. Qanday hollarda Bash Pythondan ko'ra yaxshiroq ishlatiladi?

---

# 85. Amaliy topshiriqlar

## Topshiriq 1. Birinchi Bash-skript

Fayl yarating:

```text
hello.sh
```

Dastur yozing, u:

1. foydalanuvchi nomini chiqarsin;
2. joriy katalogni chiqarsin;
3. joriy sanani chiqarsin;
4. kompyuter nomini chiqarsin.

Quyidagilarni ishlating:

```bash
whoami
pwd
date
hostname
```

---

## Topshiriq 2. Kalkulyator

Skript yarating:

```text
calculator.sh
```

Skript ikkita sonni qabul qilishi kerak:

```bash
./calculator.sh 10 5
```

va chiqarishi kerak:

```text
Addition: 15
Subtraction: 5
Multiplication: 50
Division: 2
```

Argumentlar sonini tekshirishni ham nazarda tuting.

---

## Topshiriq 3. Fayl tekshirish

Skript yarating:

```bash
./check.sh filename
```

Skript quyidagilarni aniqlashi kerak:

* fayl mavjudmi;
* u oddiy faylmi;
* uni o'qish mumkinmi;
* uni o'zgartirish mumkinmi;
* uni bajarish mumkinmi.

---

## Topshiriq 4. Fayllarni qidirish

Skript yarating:

```bash
./find_python.sh /home/user/projects
```

U `.py` kengaytmali barcha fayllarni topishi kerak.

---

## Topshiriq 5. Log-faylni tahlil qilish

Quyidagi fayl mavjud:

```text
application.log
```

Skript yozing, u quyidagilarni ko'rsatsin:

* satrlar soni;
* `ERROR` bilan bo'lgan satrlar soni;
* `WARNING` bilan bo'lgan satrlar soni;
* faylning oxirgi 20 satri.

Quyidagilarni ishlatish mumkin:

```bash
wc
grep
tail
```

---

## Topshiriq 6. Diskni monitoring qilish

Skript yozing, u:

1. ildiz bo'limining ishlatilish foizini olsin;
2. uning qiymatini chiqarsin;
3. agar ishlatilish 80% dan ko'p bo'lsa, ogohlantirish chiqarsin;
4. agar 90% dan ko'p bo'lsa, `1` kodi bilan ishni tugatsin.

---

## Topshiriq 7. Zaxira nusxalash

Yarating:

```text
backup.sh
```

Skript quyidagilarni bajarishi kerak:

1. katalogni qabul qilish;
2. uning mavjudligini tekshirish;
3. zaxira nusxa katalogini yaratish;
4. `.tar.gz` arxivini yaratish;
5. nomga joriy sanani qo'shish;
6. muvaffaqiyat yoki xato haqida xabar berish.

---

## Topshiriq 8. Oddiy menyu

Interaktiv menyu yarating:

```text
1. Show date
2. Show users
3. Show disk usage
4. Show memory
5. Exit
```

`case` konstruktsiyasini ishlating.

---

# Xulosa

Buyruq qobig'i operatsion tizim bilan o'zaro aloqaning eng muhim vositasidir.

U foydalanuvchiga nafaqat alohida buyruqlarni bajarishga, balki murakkab avtomatlashtirish ssenariylarini yaratishga ham imkon beradi.

Ushbu mavzuning eng muhim tushunchalari:

**Shell → buyruq → jarayon → tizim chaqiruvlari → yadro → apparat ta'minoti.**

Turli qobiqlar orasida ayniqsa quyidagilar muhim:

* **sh** — tarixiy va ko'chma Unix-qobiq;
* **Bash** — Linux va Unixning eng mashhur qobiqlaridan biri;
* **Zsh** — keng sozlash imkoniyatlariga ega zamonaviy interaktiv qobiq;
* **Fish** — qulay interaktiv qobiq;
* **PowerShell** — Microsoftning kuchli buyruq qobig'i;
* **cmd.exe** — Windowsning klassik buyruq qobig'i.

Bash oddiy buyruqlarni bajarishdan haqiqiy dasturlashga o'tish imkonini beradi: o'zgaruvchilar, shartlar, sikllar, funksiyalar, massivlar, xatolarni qayta ishlash, buyruq satri argumentlari va boshqa dasturlar bilan o'zaro aloqadan foydalanish.

Bashning asosiy ustunligi shundaki, u standart Unix/Linux vositalarining juda ko'p sonini yagona avtomatlashtirish mexanizmiga birlashtiradi.

Shuning uchun Bash ni bilish Linux, serverlar, DevOps, Docker, CI/CD va tizim boshqarishi bilan ishlash uchun muhim ko'nikmadir.