0.3-bob: Terminal / buyruq qatori (bash asoslari)

0-QISM — TAYYORGARLIK · 3-mavzu

1. Kirish va motivatsiya

Hozirgacha kompyuter bilan, ehtimol, sichqoncha orqali gaplashgansiz: papkani ochish uchun ustiga bosasiz, faylni ko'chirish uchun sudraysiz. Bu — GUI (Graphical User Interface — grafik interfeys). U qulay, lekin dasturchi uchun sekin va cheklangan.

Endi boshqa yo'lni o'rganamiz — terminal (buyruq qatori) orqali kompyuterga matn buyruq berish. Bu — CLI (Command-Line Interface — buyruq qatori interfeysi).

O'xshatish: GUI — bu restoranda menyudagi rasmlarga barmoq bilan ko'rsatish. CLI — bu ofitsiantga to'g'ridan-to'g'ri, aniq so'z bilan buyurtma berish. Ikkinchisi tezroq, aniqroq va siz istalgan narsani so'rashingiz mumkin — faqat "tilini" bilish kerak.

Nega bu majburiy ko'nikma (xohish emas)?

• Git, npm, Docker, SSH — siz ishlatadigan deyarli barcha jiddiy dasturchi asboblari avval CLI, ko'pincha faqat CLI. (git commit, npm install, docker run — bularning hammasi terminal.)
• Serverlar GUI'siz. Loyihangizni Linux serverga joylaganingizda (0.2, 10-QISM), u yerda sichqoncha yo'q — faqat terminal (SSH orqali). Terminalsiz — serverga qo'l urolmaysiz.
• Tezlik va avtomatlashtirish. 1000 ta faylni qayta nomlash sichqoncha bilan — bir kun; terminalda — bir qator. Takrorlanuvchi ishlarni skript qilib avtomatlashtirasiz.
• Aniqlik va aniq xatolar. GUI "nimadir xato bo'ldi" deydi; terminal aniq EACCES: permission denied deydi (0.2-bobni eslang).

Bu bobda o'rgangan path va ruxsatlar 0.2-bob — to'g'ridan-to'g'ri ishga tushadi. Bob oxiriga kelib, terminaldan qo'rqmaydigan, balki uni sevadigan bo'lasiz.

Windows foydalanuvchisiga muhim eslatma: siz Windows'dasiz, va unda PowerShell hamda cmd bor. Lekin dasturchilik dunyosi (git, server, Docker, CI/CD) bash (Unix shell) tilida gaplashadi. Shuning uchun bu bobda bashni o'rganamiz. Windows'da bash'ni olishning eng oson yo'li — Git Bash (Git bilan birga keladi, 0.7-bob) yoki WSL (Windows Subsystem for Linux). Eng keng tarqalgan buyruqlarning PowerShell muqobillarini ham jadvalda beramiz, shunda o'z mashinangizda ham yo'qolmaysiz.

2. Nazariya — chuqur tushuntirish

2.1. Terminal, shell va prompt — uchta har xil narsa

Ko'pchilik bu uchta so'zni aralashtiradi. Aniq farqlaylik:

• Terminal (terminal emulyatori) — bu oyna/dastur. U sizning yozganingizni (matn) qabul qiladi va natijani (matn) ko'rsatadi. Masalan: Windows Terminal, iTerm, GNOME Terminal. U faqat "ekran va klaviatura" vazifasini bajaradi — o'zi buyruqni tushunmaydi.
• Shell (qobiq) — bu terminal ichida ishlaydigan dastur bo'lib, sizning buyrug'ingni o'qiydi, tushunadi va bajaradi. Masalan: bash, zsh, fish (Unix); PowerShell, cmd (Windows). Aql — shu yerda.
• Prompt — bu shell sizdan buyruq kutib turganda ko'rsatadigan matn. Masalan ali@pc:~/loyiha$ . Oxiridagi $ (yoki #, >) — "buyrug'ingizni yoz" degani.

  ┌─ TERMINAL (oyna) ──────────────────────────┐
  │ ali@pc:~/loyiha$ ls -l                       │  prompt + sizning buyrug'ingiz
  │ total 8                                      │
  │ -rw-r--r-- 1 ali ali  220 Jun 21 index.js   │  SHELL bajargan natija
  │ ali@pc:~/loyiha$ ▮                            │  keyingi buyruqni kutadi
  └────────────────────────────────────────────┘
       ▲                    ▲
     terminal             shell (bash) ishlaydi shu yerda

O'xshatish: terminal — telefon apparati (gaplashish vositasi). shell — narigi tomondagi odam (gaplaringni tushunib, ish qiladigan). prompt — uning "labbay, eshitaman" deyishi.

2.2. Shell qanday ishlaydi? (REPL tsikli)

Shell — aslida abadiy takrorlanadigan oddiy tsikl. Inglizcha REPL: Read Eval Print Loop:

        ┌──────────────────────────────────────┐
        ▼                                        │
   1. READ    buyrug'ingni o'qiydi (Enter bosguningcha)
        │
        ▼
   2. PARSE   buyruqni bo'laklarga ajratadi:
        │        dastur nomi + flaglar + argumentlar
        ▼
   3. FIND    dasturni topadi (PATH bo'yicha — 2.4)
        │
        ▼
   4. EXECUTE dasturni PROCESS qilib ishga tushiradi (0.2-bob!)
        │        natijani ekranga chiqaradi
        └──────────────────────────────────────┘
              (va yana prompt ko'rsatib, kutadi)

Diqqat qiling: 4-qadamda shell aslida yangi process yaratadi (0.2-bob, fork/exec). Ya'ni ls deb yozsangiz — bu fayl tizimidagi ls dasturini process qilib ishga tushirish. Terminal — bu dasturlarni ishga tushirish darvozasi.

2.3. Buyruq tuzilishi (anatomiyasi)

Har bir terminal buyrug'i odatda uch qismdan iborat:

   ls   -l -a   /home/ali
   │    │       │
   │    │       └── ARGUMENT(lar): nima ustida ishlash (qaysi papka/fayl)
   │    └────────── OPTION/FLAG(lar): qanday ishlash (xulq-atvorni o'zgartiradi)
   └─────────────── COMMAND: qaysi dastur

• Command — dastur nomi (ls, cd, git, node).
• Option / Flag — dasturning xulqini o'zgartiradi:
  • qisqa flag: bitta - va bitta harf — -l, -a. Bir nechtasini birlashtirsa bo'ladi: -la ≡ -l -a.
  • uzun flag: ikkita -- va so'z — --all, --help. O'qishga tushunarli.
• Argument — dastur nima ustida ishlashi (fayl, papka, matn).

2.4. PATH — shell dasturni qanday topadi?

Siz ls deb yozsangiz, shell ls dasturini qayerdan topadi? Javob — PATH degan muhit o'zgaruvchisida (environment variable). PATH — bu papkalar ro'yxati; shell buyruqni ko'rganda shu papkalarni navbatma-navbat qidiradi va birinchi topilganini ishga tushiradi.

PATH = /usr/local/bin : /usr/bin : /bin : /home/ali/.npm/bin
                    (papkalar ":" bilan ajratiladi — Windows'da ";")

Shuning uchun yangi dastur o'rnatib (masalan node), terminal "command not found" desa — odatda uning papkasi PATH'da yo'q. (Bu — 0.7-bobda Node o'rnatishda tez-tez uchraydi.)

Qaysi dastur ishlayotganini bilish uchun: which node (Unix) yoki type node (bash builtin) — dastur qaysi fayldan ishga tushayotganini aytadi.

2.5. Shell builtin vs tashqi dastur (coreutils)

Buyruqlar ikki xil bo'ladi (GNU rasmiy hujjatlariga ko'ra):

• Builtin (ichki) buyruqlar — shell'ning o'ziga qurilgan: cd, pwd, echo, type, export. Ular tashqi fayl emas.
• Tashqi dasturlar (coreutils) — diskda alohida fayl: ls, mkdir, rm, cp, mv, cat. Bular GNU Coreutils to'plamidan (Linux'ning asosiy asboblari).

Nega cd aynan builtin bo'lishi shart? Chunki cd shell'ning o'z joriy papkasini (cwd — 0.2-bob) o'zgartiradi. Agar u alohida process bo'lsaydi, faqat o'sha process'ning papkasini o'zgartirib, o'lib ketardi — ota shell'ning papkasi o'zgarmasdi (0.2: process'lar xotirasi ajratilgan!). Shuning uchun cd shell'ning o'zi ichida bajarilishi kerak.

type cd     # "cd is a shell builtin"
type ls     # "ls is /usr/bin/ls"  (tashqi dastur)

2.6. Standart oqimlar (streams): stdin, stdout, stderr

Bu — Unix falsafasining yuragi. Har bir dastur uchun uchta oqim (kanal) ochiq turadi (rasmiy nomlar va raqamlari — file descriptor):

            ┌─────────────┐
  stdin ───▶│   DASTUR     │───▶ stdout  (odatdagi natija)
   (0)      │  (process)   │ (1)
            │              │───▶ stderr  (xato xabarlari)
            └─────────────┘ (2)

Nega stdout va stderr alohida? Shunday qilinsaki, natijani faylga yozib, xatolarni baribir ekranda ko'rishingiz mumkin bo'lsin (yoki aksincha). Bu — keyingi 2.7-bob qudratli imkoniyatni beradi.

Unix falsafasi: "Har bir dastur bitta ishni yaxshi bajarsin. Dasturlar matn oqimlari orqali muloqot qilsin." Mana shu sodda g'oya — terminalni shu qadar kuchli qiladi: kichik asboblarni bir-biriga ulab, murakkab ishni yasaysiz.

2.7. Pipe (|) va redirection (>) — oqimlarni boshqarish

Aynan shu — terminalning eng kuchli "sehri".

Redirection (yo'naltirish) — oqimni ekran o'rniga faylga (yoki fayldan) yo'naltirish:

Pipe (quvur, |) — bir dasturning stdoutini boshqa dasturning stdiniga ulaydi. Ya'ni birinchi dastur natijasi — ikkinchi dasturning kirishi bo'ladi:

  ls -l    │    grep ".js"    │    wc -l
  └──┬──┘  ▲    └────┬────┘   ▲   └──┬──┘
  fayllarni  pipe  faqat .js   pipe  qatorlarni
  ro'yxatla        larni filtr      sana
                                = "nechta .js fayl bor?"

Mana shu ulanish (composition) — bir nechta sodda asbobni ulab, kuchli natija olish — Unix'ning eng go'zal g'oyasi. (Diqqat: oddiy | faqat stdoutni uzatadi; xatolarni ham uzatish uchun |& yoki 2>&1 |.)

2.8. Fayl tizimida harakat (0.2-bobning amaliyoti)

Terminal har doim qaysidir papkada turadi — bu joriy papka (cwd, 0.2-bob). Buyruqlaringiz shu papkaga nisbatan ishlaydi. Asosiy harakat buyruqlari:

• pwd — hozir qayerdaman? (print working directory)
• ls — bu yerda nima bor? (list)
• cd <papka> — boshqa papkaga o't (change directory)

Path qoidalari aynan 0.2-bobdagidek: . (joriy), .. (ota), ~ (home), / (root), absolute va relative.

2.9. Exit code ($?) — buyruq muvaffaqiyatli bo'ldimi?

Har bir buyruq tugagach, ortidan ko'rinmaydigan bitta son qoldiradi — bu exit code (chiqish kodi, yoki "exit status"). Qoida sodda va Unix bo'ylab yagona:

• 0 — muvaffaqiyat ("hammasi joyida"). Faqat nol.
• 0 dan boshqa har qanday son (1, 2, 127, ...) — xato. Son turi xatoni bildiradi (masalan 127 — "command not found").

Oldingi buyruqning exit code'ini maxsus o'zgaruvchi $? ushlab turadi:

ls /mavjud-papka
echo $?              # 0   buyruq muvaffaqiyatli bo'ldi

ls /yoq-papka
echo $?              # 2   xato (papka topilmadi)

grep "yoq-soz" fayl.txt
echo $?              # 1   grep hech nima topmadi (bu ham "xato" deb sanaladi)

O'xshatish: exit code — bu xizmatchi ish tugagach beradigan qisqa hisobot: "Bajardim" (0) yoki "Bajara olmadim, sababi shu raqamda" (≠0). Siz ko'rmasangiz ham, shell har doim eshitadi — keyingi 2.10-bob zanjir aynan shunga tayanadi.

Bu — shunchaki nazariya emas: skriptlar, CI/CD 10.5-bob va &&/|| zanjiri butunlay exit code ustiga qurilgan. "Bildirishlar yashil bo'ldimi?" degan savol aslida "exit code 0 bo'ldimi?" degani.

2.10. Buyruqlarni zanjirlash (&&, ||, ;)

Bir qatorda bir nechta buyruqni ulashning uch usuli bor — va ular exit code'ga 2.9-bob qarab har xil ishlaydi:

mkdir loyiha && cd loyiha       # papka YARALSAGINA ichiga kiramiz (xavfsiz)
mkdir loyiha ; cd loyiha        # papka yaralmasa ham kirishga urinadi (xavfli)

npm test && npm run deploy      # test O'TSAGINA deploy qilamiz
./build.sh || echo "BUILD UZILDI"   # build YIQILSA, xabar chiqaramiz

&& va || ni birga ishlatib, sodda "agar-bo'lmasa" mantig'ini yasash mumkin:

ping -c1 google.com && echo "Internet bor" || echo "Internet yo'q"

Nega bu muhim? npm install && npm run build && npm start kabi zanjirlarni har kuni ko'rasiz: har bir bosqich oldingisi muvaffaqiyatli bo'lganda ishlaydi. Bironta bosqich yiqilsa — zanjir o'sha yerda to'xtaydi va siz buzuq holatni ishga tushirib yubormaysiz.

2.11. Environment variable — shell xotirasi (export, $VAR)

Shell o'zida o'zgaruvchilar (variables) saqlaydi — nom va qiymat juftliklari. PATH 2.4-bob — ulardan eng mashhuri. Ikki turi bor:

• Oddiy (shell) o'zgaruvchi — faqat shu shell ichida yashaydi.
• Environment (muhit) o'zgaruvchi — export qilingani; u shelldan ishga tushgan barcha child-process'larga (0.2-bob) ham uzatiladi.

NOM="Ali"                 # oddiy o'zgaruvchi (= atrofida BO'SH JOY YO'Q — muhim!)
echo "$NOM"               # qiymatni o'qish: $ bilan.  Ali

export API_URL="http://localhost:3000"   # endi child-process'lar ham ko'radi
node app.js               # app.js ichida process.env.API_URL  shu qiymat

echo "$PATH"              # PATH ni o'qish
echo "$HOME"              # uy-papka, "$USER" — foydalanuvchi nomi
printenv                  # barcha environment o'zgaruvchilarni ro'yxatlash

0.2-bobga bog'lash: environment o'zgaruvchilar — child-process'ga uzatiladigan meros. Process tugasa, uning o'zgaruvchilari ham o'ladi; ota-shellga qaytmaydi (xuddi cd builtin bo'lishi shart bo'lgani kabi — 2.5). Shuning uchun bir terminalda export qilgan o'zgaruvchi boshqa terminalda ko'rinmaydi.

Maxfiy kalitlar (API key, parol) ko'pincha aynan environment variable orqali beriladi — kod ichiga yozib qo'yilmaydi (0.2-bob, .env va chmod 600). Buni 5-QISM (Node.js) da process.env bilan ko'rasiz.

2.12. Process boshqaruvi: foreground, background, ps, kill

Buyruq ishga tushganda u process bo'ladi (0.2-bob). Odatda u foreground (oldingi planda) ishlaydi — tugaguncha terminal band turadi. Lekin uni background (orqa planda) ga ham qo'yish mumkin:

node server.js &     # serverni background'da ishga tushir, terminal bo'sh qoladi
jobs                 # [1]+ Running   node server.js &

Process'larni butun tizim bo'ylab ko'rish va to'xtatish:

ps aux               # barcha ishlayotgan process'lar (PID — 0.2-bob!)
ps aux | grep node   # faqat "node" so'zi bor process'larni topish (pipe — 2.7)

kill 12345           # PID 12345 ga "muloyim to'xta" signali (SIGTERM)
kill -9 12345        # MAJBURIY to'xtatish (SIGKILL) — process javob bermasa

kill -9 — oxirgi chora. kill (SIGTERM) process'ga "o'zingizni tartibli yig'ishtir va to'xta" deydi — u fayllarni saqlab, ulanishlarni yopib chiqadi. kill -9 (SIGKILL) esa "shu zahoti o'ldir" — process tozalanishga ulgurmaydi (ochiq fayl buzilishi mumkin). Avval oddiy kill, faqat javob bermasa -9.

Real holat: "port band" (EADDRINUSE, 0.2-bobni eslang) — eski node process portni qo'yib yubormagani. Yechim: ps aux | grep node bilan PID'ni toping, so'ng kill <PID>.

3. Sintaksis va yordam olish

Har bir buyruqning o'z yordami bor — yodlash shart emas, so'rashni bilsangiz yetarli:

ls --help        # buyruqning qisqa yordamini ko'rsatadi (ko'p dasturda bor)
man ls           # to'liq qo'llanma (manual) — "q" bilan chiqasiz (Unix)
type cd          # buyruq builtin'mi yoki tashqi dasturmi
which node       # dastur qaysi fayldan ishlayapti

Maslahat: man ba'zan juda uzun. Zamonaviy, misolli qisqa yordam uchun tldr degan asbob bor (tldr tar — eng ko'p ishlatiladigan misollarni darrov ko'rsatadi). Uni keyinroq o'rnatib qo'yish foydali.

Klaviatura — terminalda tezlik kaliti:

4. Batafsil kod namunalari (asosiy buyruqlar)

Quyidagilarni Git Bash yoki WSL (yoki Linux/macOS terminal)da sinab ko'ring. Har qatorga izoh berilgan.

4.1. Harakatlanish va ko'rish

pwd                 # hozir qaysi papkadaman? (masalan /home/ali)

ls                  # joriy papkadagi fayl/papkalar ro'yxati
ls -l               # batafsil: ruxsat, ega, hajm, sana (0.2-bobdagi rwx!)
ls -a               # yashirin (.bilan boshlangan) fayllarni ham ko'rsat
ls -la              # ikkalasi birga (flaglarni birlashtirdik)
ls -lh              # hajmni odam o'qiydigan ko'rinishda (KB/MB — 0.1-bob)

cd loyiha           # "loyiha" papkasiga kir (relative)
cd ..               # bir pog'ona yuqoriga (ota papka)
cd ~                # home papkaga qaytish
cd /                # ildizga (root) o'tish (absolute)
cd -                # OLDINGI turgan papkaga qaytish (juda qulay)

4.2. Yaratish va ko'rish

mkdir yangi-papka          # papka yaratish
mkdir -p a/b/c             # -p: oraliq papkalarni ham yaratadi (a, a/b, a/b/c)

touch index.js             # bo'sh fayl yaratish (yoki sanasini yangilash)

echo "Salom"               # matnni ekranga chiqarish (stdout)
echo "Salom" > salom.txt   # o'sha matnni faylga YOZISH (yangidan)
echo "Yana" >> salom.txt   # faylga QO'SHISH (oxiriga)

cat salom.txt              # fayl mazmunini to'liq ko'rsatish
head -n 5 katta.log        # faqat dastlabki 5 qator
tail -n 5 katta.log        # faqat oxirgi 5 qator
tail -f server.log         # faylni "jonli" kuzatish (yangi qatorlar oqib turadi)

4.3. Nusxalash, ko'chirish, o'chirish

cp manba.txt nusxa.txt          # faylni nusxalash
cp -r papka1 papka2             # -r: PAPKANI (ichi bilan) nusxalash (recursive)

mv eski.txt yangi.txt           # qayta NOMLASH (move)
mv index.js src/                # faylni src/ papkasiga KO'CHIRISH

rm fayl.txt                     # faylni o'chirish
rm -r papka                     # PAPKANI (ichi bilan) o'chirish
rm -rf papka                    # -f: so'ramasdan, majburan o'chir   JUDA EHTIYOT BO'L

rm da Recycle Bin (savatcha) YO'Q. O'chirilgan fayl butunlay yo'qoladi. Ayniqsa rm -rf — eng xavfli buyruq. Ishlatishdan oldin doim pwd bilan qayerda turganingizni tekshiring (5 va 6-bo'limga qarang).

4.4. Qidirish (find, grep)

find . -name "*.js"             # joriy papka (.) ichida barcha .js fayllarni topish
find . -type d -name "test"     # nomi "test" bo'lgan PAPKALARNI topish (-type d)

grep "error" server.log         # faylda "error" so'zi bor qatorlarni topish
grep -r "TODO" src/             # -r: src/ ichidagi BARCHA fayllarda qidirish
grep -i "error" log.txt         # -i: katta-kichik harfni farqlamasdan

4.5. Pipe va redirection (2.6–2.7 amalda)

# pipe: ls natijasini grep'ga, uni wc'ga uzatamiz
ls -l | grep ".js" | wc -l      # joriy papkada nechta .js fayl borligini sanaydi

# stdout'ni faylga yozish
node app.js > natija.txt        # dastur natijasini faylga
node app.js >> natija.txt       # faylga QO'SHIB borish

# stderr'ni (xatolarni) alohida faylga
node app.js 2> xatolar.txt      # faqat xatolarni faylga

# natija + xato — ikkisini bitta faylga
node app.js > hammasi.txt 2>&1  # tartibga diqqat: avval >, keyin 2>&1

# fayldan stdin'ga
sort < ismlar.txt               # fayl mazmunini sort dasturiga kiritish

4.6. Ruxsatlar (0.2-bobning davomi)

ls -l                # ruxsatlarni ko'rish (rwxr-xr-x ko'rinishida)

chmod 600 .env       # faqat ega o'qiy/yoza oladi (maxfiy fayl — 0.2-bob)
chmod 755 deploy.sh  # ega to'liq, qolganlar o'qish+ishga tushirish
chmod +x script.sh   # faylga "ishga tushirish" (x) huquqini qo'shish

./script.sh          # bajariladigan faylni ishga tushirish ("./" — shu papkadan)

4.7. Zanjir va wildcardlar

mkdir loyiha && cd loyiha       # &&: birinchisi MUVAFFAQIYATLI bo'lsa, ikkinchisi
cd loyiha ; ls                  #  ; : ketma-ket bajar (natijaga qaramay)

rm *.log                        # * (wildcard): barcha .log fayllar
ls src/*.js                     # src/ ichidagi barcha .js fayllar
clear                           # ekranni tozalash
history                         # oldingi buyruqlar ro'yxati

5. To'g'ri va noto'g'ri holatlar

1) rm -rf ni o'ylamasdan ishlatish

#  HALOKATLI — qayerda turganingni bilmasdan
rm -rf *            # joriy papkadagi HAMMA NARSANI o'chirib yuboradi!
rm -rf /            #  butun tizimni o'chirishga urinish (afsona darajasidagi xato)

#  TO'G'RI — avval tekshir, keyin o'chir
pwd                 # qayerdaman?
ls                  # nimani o'chiryapman?
rm -r eski-papka    # aniq nom bilan, kerak bo'lmasa -f siz

2) Bo'sh joyli (space) nomlarni tirnoqsiz yozish

#  NOTO'G'RI — shell buni IKKI argument deb o'qiydi: "My" va "File.txt"
cat My File.txt

#  TO'G'RI — tirnoqga ol (yoki bo'shliqni \ bilan "qoch")
cat "My File.txt"
cat My\ File.txt

3) Hammaga sudo (root huquq) berib yuborish

#  NOTO'G'RI — "permission denied" ko'rsang darrov sudo bilan urish
sudo npm install -g paket    # global, lekin keyinroq ruxsat tartibsizligi keltiradi

#  TO'G'RI — avval NEGA ruxsat yo'qligini tushun (0.2-bob, EACCES).
#    O'zingga tegishli papkada ishla; sudo'ni faqat haqiqatan kerak bo'lganda.

Nega: sudo — "administrator sifatida bajar" degani. Keraksiz sudo fayllar egasini buzadi va xavfsizlik teshigi ochadi.

4) Windows buyruqlarini bash deb o'ylash

#  Git Bash'da Windows/cmd buyruqlari ishlamaydi yoki boshqacha
dir                 # cmd buyrug'i (bash'da "ls" kerak)

#  bash'da to'g'ri muqobillar
ls                  # dir o'rniga

6. Keng tarqalgan xatolar va yechimlari

Xato 1 — command not found

bash: node: command not found

Sababi: dastur o'rnatilmagan yoki uning papkasi PATH'da yo'q 2.4-bob. Yechimi: dasturni o'rnatish 0.7-bob; o'rnatilgan bo'lsa, PATH'ga papkasini qo'shish; which/type bilan tekshirish; terminalni qayta ochish (PATH yangilanishi uchun).

Xato 2 — No such file or directory

cd: loyihaa: No such file or directory

Sababi: noto'g'ri nom/path (ko'pincha imlo xatosi yoki noto'g'ri papkada turibsiz). Yechimi: pwd + ls bilan qayerda va nima borligini tekshiring; Tab bilan avto-to'ldirib, imlo xatosining oldini oling. (0.2: bu — ENOENTning terminal ko'rinishi.)

Xato 3 — Permission denied

bash: ./deploy.sh: Permission denied

Sababi: faylda ishga tushirish (x) huquqi yo'q (0.2-bob, ruxsatlar). Yechimi: chmod +x deploy.sh bilan x huquqini berish, keyin ./deploy.sh.

Xato 4 — rm: cannot remove 'papka': Is a directory

rm: cannot remove 'papka': Is a directory

Sababi: oddiy rm faqat faylni o'chiradi, papkani emas. Yechimi: rm -r papka (recursive). (0.2: EISDIRni eslang.)

Xato 5 — Windows'da "bash topilmadi" / buyruqlar ishlamayapti

Sababi: cmd/PowerShell'da bash buyruqlarini yozyapsiz. Yechimi: Git Bashni oching (Git o'rnatilgach) yoki WSLni ishga tushiring (wsl deb). Eng keng tarqalgan muqobillar:

Halokatli buyruqlar haqida. Internetda topgan buyruqni tushunmasdan nusxalab ishlatmang — ayniqsa rm -rf, sudo, > fayl (faylni yo'q qiladi) borlarini. Avval man/--help bilan tekshiring.

7. Integratsiya — bu mavzu stack'ning qayerida uchraydi

Terminal — bu butun dasturchilik dunyosiga darvoza. Hammasi shu yerda yashaydi:

• Git (4-QISM): git add, git commit, git push — barchasi terminal.
• npm va Node (0.7, 5.2): npm install, npm run dev, node app.js.
• package.json scripts 5.2-bob: terminal buyruqlarini nomlab saqlab qo'yish.
• Docker 10.3-bob: docker build, docker run, docker compose up.
• SSH va serverlar 10.1-bob: uzoq Linux serverni faqat terminal orqali boshqarasiz.
• CI/CD 10.5-bob: GitHub Actions — aslida bulut serverda ishlaydigan terminal buyruqlari ro'yxati.
• Ruxsatlar va fayl tizimi 0.2-bob: chmod, cd, path — shu bobda amalga oshdi.
• Pipe falsafasi 2.6-bob: keyinchalik oqim (stream, 5.4) va ma'lumotni bosqichma-bosqich qayta ishlashda qaytadi.

Qisqasi: terminalni yaxshi bilgan dasturchi bir necha barobar tezroq ishlaydi.

8. Eng yaxshi amaliyotlar (best practices)

• Tab ni odat qiling. Nomni to'liq yozmang — yarimini yozib Tab bosing. Tezlik + imlo xatosi yo'q.
• Ctrl+C, Ctrl+R, ni o'rganing. Bular kunlik ishingizni tezlashtiradi.
• Yodlamang — so'rashni biling. --help, man, tldr — har doim qo'lingiz ostida.
• rm dan oldin pwd + ls. Doimo. Bu odat sizni katta falokatdan saqlaydi.
• Path va nomlarni tirnoqga oling (bo'sh joy bo'lsa) — "my file.txt".
• Bitta shell'ni yaxshi o'rganing (bash) — qolganlariga oson o'tasiz.
• Tarixdan foydalaning. Murakkab buyruqni qayta yozmang — Ctrl+R bilan toping.
• Tushunmasdan nusxalab ishlatmang. Ayniqsa sudo, rm -rf, curl ... | bash larni.
• Keyinroq: alias va .bashrc. Tez-tez ishlatadigan uzun buyruqlarni qisqa nom (alias) qiling — alias gs="git status". (Bu — 0.7/15-bobda.)

9. Amaliy loyiha: "Terminal Ustasi — Loyiha Skeletini Qo'lda Qurish"

Bu loyiha sichqonchaga umuman tegmasdan, faqat terminal bilan bajariladi. Maqsad — buyruqlarni "his qilib", barmoq xotirasiga o'tkazish.

Maqsad

Faraz qiling, yangi web-loyiha boshlayapsiz. Uning butun papka-fayl skeletini faqat terminaldan yarating, to'ldiring, ko'chiring va ruxsatlarni sozlang. So'ng — shu jarayonni avtomatlashtiradigan kichik .sh skript yozing.

Talablar (requirements)

A qismi — qo'lda (terminal buyruqlari bilan):

1. mening-loyiham nomli papka yarating va ichiga kiring.
2. Ichida quyidagi tuzilmani yarating (faqat mkdir, touch, mkdir -p bilan):
   text

   mening-loyiham/
   ├── src/
   │   ├── index.js
   │   └── utils/helpers.js
   ├── public/
   ├── tests/
   ├── .env
   ├── .gitignore
   └── README.md

3. README.md ichiga echo bilan loyiha nomini yozing (>); keyin yana bir qator qo'shing (>>).
4. .gitignore ichiga node_modules va .env qatorlarini yozing.
5. .env faylga faqat ega o'qiy oladigan ruxsat bering (chmod 600) va ls -l bilan tekshiring.
6. index.js ni src/utils/ ichiga nusxalang (cp), keyin nomini o'zgartiring.
7. Butun tests/ papkasini o'chiring (rm -r).
8. find bilan loyihadagi barcha .js fayllarni toping va ularning sonini wc -l bilan sanang (pipe).

B qismi — avtomatlashtirish (bonus, lekin tavsiya): 9. Yuqordagi skeletni bitta ishga tushirishda yaratadigan setup.sh skript yozing. 10. Unga chmod +x bering va ./setup.sh bilan ishga tushiring.

Maslahatlar (hint)

• Oraliq papkalar uchun mkdir -p src/utils — bitta buyruqda butun zanjirni yaratadi.
• Faylga yozishda: yangidan = >, qo'shish = >> (2.7-bo'lim).
• Ruxsatni tekshirish: ls -l .env rw------- (ya'ni 600) ko'rinishi kerak.
• .js larni sanash: find . -name "*.js" | wc -l (pipe — 2.7).
• setup.sh ichida buyruqlarni xuddi terminalga yozganingizdek, har qatorga bittadan yozasiz. Birinchi qatorga #!/usr/bin/env bash qo'ying (bu — "shebang", skript qaysi shell'da ishlashini aytadi).
• Skriptni faqat bajariladigan qilish uchun chmod +x setup.sh 4.6-bob.

"Tayyor" mezonlari (acceptance criteria)

• tree yoki ls -R skeletni talab qilingandek ko'rsatadi.
• ls -l .env ruxsat rw------- (600).
• README.md ichida kamida 2 qator bor (cat README.md bilan tekshiring).
• .gitignore ichida node_modules va .env bor.
• find . -name "*.js" | wc -l to'g'ri sonni qaytaradi.
• tests/ papkasi o'chirilgan.
• (Bonus) ./setup.sh ni bo'sh papkada ishga tushirsangiz, xuddi shu skelet qayta yaraladi.

Yechim kodi ataylab berilmagan — bu loyihani o'zingiz yozib ko'ring.

10. Xulosa va keyingi bobga ko'prik

Bu bobda dasturchining eng kuchli quroli — terminalni o'rgandik:

• Terminal (oyna), shell (bash — buyruqni tushunadi), prompt (kutib turadigan matn) — uchta har xil narsa.
• Shell — REPL tsikli: buyruqni o'qib, dasturni process qilib ishga tushiradi (0.2-bob).
• Buyruq = command + flag + argument. Dasturlar PATH orqali topiladi. cd builtin bo'lishi shart (cwd'ni o'zgartiradi).
• Uchta oqim: stdin (0), stdout (1), stderr (2). Pipe (|) va redirection (>, >>, 2>) — kichik asboblarni ulab, katta ish yasash (Unix falsafasi).
• Asosiy buyruqlar: pwd, ls, cd, mkdir, touch, cat, cp, mv, rm, find, grep, chmod.
• rm -rf — savatchasiz, qaytmas. Doim pwd+ls bilan tekshiring.
• Windows'da bash uchun Git Bash yoki WSL.

Keyingi bob — 0.4-bob: Internet va web qanday ishlaydi (client–server, HTTP/HTTPS, request/response, status kodlar, DNS). Endi bitta mashinani boshqaramiz; navbat — mashinalar bir-biri bilan qanday gaplashishiga. Bu — butun backend va frontend ishining poydevori: har bir veb-sahifa, har bir API so'rovi shu tushunchalarga tayanadi.

Foydalanilgan rasmiy/ishonchli manbalar

• GNU Bash Reference Manual — shell, builtin buyruqlar, redirection
• GNU Coreutils Manual — ls, cp, mv, rm, mkdir va boshqalar
• POSIX / Linux man-pages — standart oqimlar (stdin/stdout/stderr), file descriptorlar
• GNU Coreutils FAQ — builtin va tashqi dastur farqi