0.2-bob: Operatsion tizimlar va fayl tizimi

0-QISM — TAYYORGARLIK · 2-mavzu

1. Kirish va motivatsiya

Oldingi bobda (0.1) temirni — CPU, RAM, disk va binary'ni — o'rgandik. Lekin siz yozadigan dastur o'sha temirga to'g'ridan-to'g'ri murojaat qilmaydi. Siz hech qachon "RAM'ning 5-manziliga shu baytni yoz" yoki "diskning falon sektoridan o'qi" deb yozmaysiz. O'rtada bir vositachi turadi — operatsion tizim (OS).

Tasavvur qiling: siz restoranga keldingiz va oshxonaga bostirib kirib, o'zingiz pechka yoqib, masalliq qidirmaysiz. Buning o'rniga ofitsiantga buyurtma berasiz, u esa oshxona bilan gaplashadi. Operatsion tizim — aynan shu ofitsiant: siz (dastur) unga "shu faylni och", "tarmoqdan ma'lumot ol", "bu jarayonni ishga tushir" deysiz, u esa temir (oshxona) bilan murojaat qiladi va natijani sizga qaytaradi.

Nega bu dasturchi uchun muhim?

• Siz yozadigan har bir fayl o'qish (fs.readFile), tarmoq so'rovi (fetch), jarayon ishga tushirish — aslida OS'ga yuborilgan iltimos (system call).
• ENOENT, EACCES, EADDRINUSE kabi xatolar — bularning hammasi OSdan keladigan xabarlar. Ularni tushunish uchun OS qanday ishlashini bilish kerak.
• Siz kodingizni Windowsda yozasiz, lekin u Linux serverda ishlaydi. Windows'da ishlagan kod Linux'da buziladigan eng keng tarqalgan bug'lar — aynan OS va fayl tizimi farqlaridan kelib chiqadi (path ajratuvchisi, harf registriga sezgirlik).
• Docker, deploy, SSH, fayl yuklash, .env, ruxsatlar (permissions) — bularning hammasi shu bobdagi tushunchalarga tayanadi.

Bu bobni tushunsangiz, "nega mening kompyuterimda ishlaydi, lekin serverda ishlamaydi?" degan eng alamli savol sizga kamroq beriladi.

2. Nazariya — chuqur tushuntirish

2.1. Operatsion tizim nima va u nima qiladi?

Operatsion tizim (OS) — bu temir (hardware) bilan dasturlar (software) o'rtasida turadigan boshqaruvchi dastur. U ikki katta vazifani bajaradi:

1. Resurslarni boshqaradi — CPU, RAM, disk, tarmoq, qurilmalar (printer, klaviatura) cheksiz emas. OS ularni o'nlab dasturlar o'rtasida adolatli taqsimlaydi.
2. Soddalashtirilgan interfeys beradi — har bir dastur diskning fizik tuzilishini, RAM manzillarini bilishi shart emas. OS "fayl", "papka", "jarayon" kabi qulay tushunchalar beradi.

Tizim qatlamlarini shunday tasavvur qiling:

   ┌─────────────────────────────────────────┐
   │   SIZNING DASTURINGIZ (Node.js, brauzer) │   user space (foydalanuvchi makoni)
   ├─────────────────────────────────────────┤
   │   Operatsion tizim — KERNEL (yadro)       │   kernel space (yadro makoni)
   │   process | xotira | fayl | tarmoq | drayver│
   ├─────────────────────────────────────────┤
   │   TEMIR: CPU · RAM · Disk · Tarmoq karta   │   hardware (0.1-bob)
   └─────────────────────────────────────────┘

OS ning asosiy vazifalari (har birini quyida ochamiz):

2.2. Kernel (yadro): kernel space vs user space

Kernel (yadro) — operatsion tizimning eng markaziy, eng kuchli qismi. U temirga to'liq murojaat qila oladi. Aynan shu kuch xavfli, shuning uchun OS xotirani ikki "makon"ga ajratadi (rasmiy Linux Kernel hujjatlaridagi tushuncha):

• Kernel space (yadro makoni) — himoyalangan xotira sohasi; faqat kernel shu yerda ishlaydi va temirga to'g'ridan-to'g'ri murojaat qiladi.
• User space (foydalanuvchi makoni) — cheklangan soha; sizning dasturingiz shu yerda ishlaydi va temirga to'g'ridan-to'g'ri tega olmaydi.

O'xshatish: bank. Kassa zali (user space) — mijozlar (dasturlar) shu yerda. Seyf xonasi (kernel space) — faqat xodimlar (kernel) kiradi. Mijoz pulni o'zi seyfdan ololmaydi; u kassirga ariza beradi (system call), kassir seyfga kirib, ishni bajaradi. Bu — xavfsizlik: bitta beadab mijoz bankning hamma pulini olib qocha olmaydi.

Nega bu ajratish kerak? Barqarorlik va xavfsizlik uchun. Agar har bir dastur RAM va diskga to'g'ridan-to'g'ri tegsa, bitta xatolik (yoki virus) butun tizimni qulatishi mumkin edi. User space dasturining xatosi faqat o'zini "o'ldiradi", boshqalarga va kernel'ga teginmaydi.

2.3. System call (tizim chaqiruvi) — ko'prik

Sizning dasturingiz temirga tegolmasligini aytdik. Unda u qanday qilib fayl o'qiydi yoki tarmoqqa chiqadi? Javob: system call orqali. Bu — user space'dan kernel space'ga o'tishning yagona rasmiy yo'li.

  Sizning kodingiz:  fs.readFile("a.txt")    user space
        │
        ▼  (system call: masalan, Linux'da `open()`, `read()`)
  ┌──────────────────────────────────────┐
  │  CPU "kernel mode"ga o'tadi (mode switch) │
  │  Kernel diskdan baytlarni o'qiydi          │
  │  CPU yana "user mode"ga qaytadi           │
  └──────────────────────────────────────┘
        │
        ▼
  Natija dasturingizga qaytadi (fayl mazmuni)

Bu o'tish — mode switch (rejim almashinuvi) deyiladi: CPU "user mode" (cheklangan) va "kernel mode" (to'liq huquqli) o'rtasida o'tadi. Bu o'tish biroz "qimmat" (sekin), shuning uchun yaxshi dasturlar keraksiz system call'larni kamaytiradi (masalan, faylni 1 baytdan o'qish o'rniga katta bo'laklab o'qish — buni 5.4 Streams bobida ko'ramiz).

Eslatma: Node.js'da fs, net, child_process modullari — aslida shu system call'larning qulay "o'rami" (wrapper). Siz JavaScript yozasiz, Node esa pardaning ortida OS'ga system call yuboradi.

2.4. Process (jarayon) va thread (oqim)

Process (jarayon) — bu ishlayotgan dastur. Diskda turgan dastur (masalan node) — shunchaki fayl. Siz uni ishga tushirsangiz, OS unga RAM ajratadi, PID (Process ID) beradi va u "process"ga aylanadi.

Har bir process'ning o'ziga xos, ajratilgan xotirasi bor. Bitta process boshqasining xotirasiga teginolmaydi (yana o'sha xavfsizlik). Shuning uchun brauzerda bitta sahifa qulasa, butun brauzer (ko'pincha) qulamaydi — har sahifa alohida process.

Thread (oqim) — bu process ichidagi bajarilish yo'nalishi. Bitta process'da bir nechta thread bo'lishi mumkin va ular bir xil xotirani baham ko'radi. Bu — 0.1-bobdagi "thread" tushunchasining davomi.

  PROCESS (o'z xotirasi bilan)
  ┌──────────────────────────────────┐
  │  Umumiy xotira (kod, ma'lumot)     │
  │   ┌────────┐  ┌────────┐  ┌────────┐│
  │   │ Thread 1│  │ Thread 2│  │ Thread 3││   xotirani BAHAM ko'radi
  │   └────────┘  └────────┘  └────────┘│
  └──────────────────────────────────┘

• Process'lar — bir-biridan ajratilgan (alohida xonalar).
• Thread'lar — bitta process ichida, umumiy xotira (bitta xonadagi bir necha kishi).

JavaScript uchun muhim: Node.js sizning kodingizni bitta asosiy threadda ishlatadi (0.1-bobda aytgandik). Og'ir ishlarni esa OS va kernel'ga "topshirib", o'zi boshqa ish bilan band bo'ladi. Bu — event loop'ning butun siri; 5.1-bobda chuqur ochamiz. Ko'p yadrodan foydalanish kerak bo'lsa, Node worker_threads yoki cluster (alohida process'lar) ishlatadi.

fork (process'ni nusxalash) va exec (uni yangi dastur bilan almashtirish) — bu Unix'dagi process yaratishning klassik system call'lari (rasmiy man-pages'da fork(2), execve(2)).

Signallar (signals) — process'ga xabar yuborish. Ishlab turgan process'ni qanday to'xtatamiz? OS unga signal — qisqa, raqamli xabar — yuboradi. Eng muhim ikkitasi (POSIX standarti, signal(7) man-page):

Farqi muhim: SIGTERM — odobli so'rov. Process uni "tutib olib" (masalan, Node'da process.on("SIGTERM", ...)), ochiq fayllarni yopib, ma'lumotlar bazasi ulanishini uzib, keyin chiroyli tugashi mumkin — bu graceful shutdown (10.2-bobda deploy'da ko'ramiz). SIGKILL esa ushlab bo'lmaydi: OS process'ni hech narsa so'ramay o'chiradi, shuning uchun u oxirgi chora. Terminalda kill <PID> — SIGTERM yuboradi; kill -9 <PID> — SIGKILL.

Zombie va orphan process'lar. Bular real serverlarda uchraydigan ikki nuqson:

• Zombie (o'lik) process — bajarib bo'lgan, lekin otasi uning yakuniy holatini ("exit code") hali o'qib olmagan process. U RAM ishlatmaydi, lekin PID jadvalida "o'lik" yozuv bo'lib qoladi. Ko'p zombie — ota dasturda bug belgisi.
• Orphan (yetim) process — otasi undan oldin o'lib ketgan, bola process. Uni Linux'da maxsus init (PID 1) process "asrab oladi" va to'g'ri tozalaydi. Docker konteynerida init bo'lmasa, zombie'lar yig'ilib qolishi mumkin — shuning uchun --init bayrog'i ishlatiladi (10.3-bob).

2.5. Scheduling va virtual xotira (qisqacha, lekin muhim)

Scheduling (rejalashtirish): kompyuterda yuzlab process ishlaydi, lekin CPU yadrolari kam (masalan 8 ta). OS har bir process'ga CPU'ni juda qisqa bo'laklarda (millisekundlar) navbatma-navbat beradi — bu context switching (kontekstni almashtirish). Shu qadar tez bo'ladiki, bizga hammasi bir vaqtda ishlayotgandek tuyuladi. (0.1-bobdagi "1 oshpaz ko'p taomni tez almashtirib pishiradi" o'xshatishi — aynan shu.)

Virtual xotira (virtual memory): har bir process "men butun RAM'ga egaman" deb o'ylaydi. Aslida OS har process'ga virtual manzillar beradi va ularni yashirincha fizik RAMga moslaydi (mapping). Agar RAM yetmasa, OS kam ishlatilayotgan bo'laklarni vaqtincha diskka ko'chiradi — bu swap (yoki Windows'da "page file") deyiladi. Swap diskda bo'lgani uchun (0.1 xotira ierarxiyasini eslang) sekin — shuning uchun "RAM yetmay qoldi, kompyuter qotib qoldi" holati yuzaga keladi.

Environment variables (muhit o'zgaruvchilari): har bir process ishga tushganda OS unga kichik "kalit=qiymat" ro'yxati beradi — bu muhit o'zgaruvchilari. Ular process'ga "qaysi muhitda ishlayapsan?" degan sozlamalarni yetkazadi: PATH (dasturlarni qaysi papkalardan qidirish), HOME (home papka), PORT, NODE_ENV (development yoki production) va h.k. Muhim xususiyat: bola process otasining muhitini meros qilib oladi. Aynan shuning uchun maxfiy ma'lumotlar (ma'lumotlar bazasi paroli, API kalit) kodga yozilmaydi, balki muhit o'zgaruvchisi orqali beriladi — server muhitida bir marta o'rnatiladi, koddan esa o'qiladi:

// process.env — joriy process'ning muhit o'zgaruvchilari (object).
console.log(process.env.PATH);     // PATH ro'yxati
console.log(process.env.NODE_ENV); // "production" | "development" | undefined
const port = process.env.PORT || 3000; // muhitdan o'qish, bo'lmasa 3000

Bu .env fayllari va dotenv (5.8-bob) hamda deploy (10-qism) uchun negiz: kod bir xil, lekin muhit o'zgaruvchilari local va serverda har xil bo'ladi.

2.6. Fayl tizimi (file system) — disk qanday tashkil etiladi

Disk 0.1-bob — aslida bittagina ulkan baytlar ketma-ketligi. Fayl tizimi (file system) — OS'ning shu baytlarni biz tushunadigan fayl va papkalarga tashkil etish usuli.

Fayl (file) — nom berilgan baytlar ketma-ketligi + metadata (fayl haqidagi ma'lumot):

• nomi (hisobot.pdf),
• hajmi (baytlarda),
• yaratilgan / o'zgartirilgan sana,
• turi va ruxsatlari (permissions),
• diskda qayerda joylashgani.

Papka / katalog (directory, folder) — aslida maxsus fayl, ichida boshqa fayllar va papkalar ro'yxati bor. Shu tarzda daraxtsimon (tree) tuzilma hosil bo'ladi:

/                       ildiz (root) — Unix'da hammasi shundan boshlanadi
├── home/
│   └── ali/            foydalanuvchi papkasi (home)
│       ├── loyiha/
│       │   ├── index.js
│       │   └── package.json
│       └── rasm.png
├── etc/                tizim sozlamalari
└── usr/                o'rnatilgan dasturlar

Inode — fayl nomi ortidagi "haqiqiy" fayl. Unix fayl tizimida (ext4 va boshqalar) faylning nomi va mazmuni alohida narsa. Fayl haqidagi barcha metadata (hajmi, ruxsatlari, sanasi, diskdagi bloklari) inode deb ataladigan tuzilmada saqlanadi; har inode'ning raqami bor (ls -i ko'rsatadi). Papka esa shunchaki "nom inode raqami" juftliklari jadvali. Ya'ni nom faylga emas, inode'ga ishora qiladi. Aynan shu sabab Unix'da faylni o'chirish system call'i unlink deb ataladi — u faqat nomni (havolani) o'chiradi; inode esa unga ishora qiluvchi oxirgi nom ham yo'qolgandagina diskdan tozalanadi.

Symbolic link vs hard link — ikki xil "yorliq". Bitta faylga ikkinchi nom (havola) berishning ikki usuli bor:

  HARD LINK (qattiq havola)            SYMBOLIC LINK (ramziy havola, symlink)
  a.txt ┐                              a.txt  ──►  (inode #42, real ma'lumot)
        ├──►  inode #42 (ma'lumot)     b.txt  ──►  "a.txt" (faqat YO'L matni)
  b.txt ┘                                          └─ a.txt o'chsa, b.txt "sinadi"

• Hard link — bir xil inode'ga ikkita teng huquqli nom. Asl faylni o'chirsangiz ham, ikkinchi nom orqali ma'lumot saqlanib qoladi (inode'ga hali havola bor). Faqat bir xil fayl tizimi ichida ishlaydi.
• Symbolic link (symlink) — alohida kichik fayl, ichida shunchaki boshqa faylning yo'li (matn) yozilgan — Windows'dagi "yorliq"ga o'xshaydi. Nishon (asl fayl) o'chsa, symlink "sinadi" (broken link). Symlink papkalararo va fayl tizimlararo ishlaydi.

Amaliy ahamiyat: node_modules ichidagi paketlar, nvm orqali Node versiyalari, Linux'dagi /usr/bin dasturlari — ko'pincha symlink orqali ulanadi. Buyruq: ln -s manba havola (symbolic), ln manba havola (hard).

2.7. Path (yo'l): absolute va relative

Path (yo'l) — faylga qanday yetib borishni ko'rsatadigan manzil. Ikki turi bor:

• Absolute (mutlaq) path — ildizdan (root) boshlangan to'liq manzil. Har doim bir xil joyni ko'rsatadi.
  • Unix: /home/ali/loyiha/index.js
  • Windows: C:\Users\Ali\loyiha\index.js
• Relative (nisbiy) path — joriy papkaga (current working directory) nisbatan. Qayerda turganingizga bog'liq.
  • index.js — shu papkadagi fayl
  • ./loyiha/index.js — . = joriy papka
  • ../rasm.png — .. = bir pog'ona yuqoridagi (ota) papka

Maxsus belgilar:

Eng muhim farq: Windows disk harflari (C:, D:) va teskari slash \ ishlatadi; Unix (Linux/macOS) esa bitta ildiz / va to'g'ri slash / ishlatadi. Aynan shu farq Windows'da yozilgan kodni Linux serverda buzadigan eng keng tarqalgan sabablardan biri. Yechimi — pathni qo'lda yozmang, balki dasturlash tilining path modulidan foydalaning (4-bo'limda ko'ramiz).

2.8. Fayl tizimi turlari (FAT32, exFAT, NTFS, ext4, APFS)

Har xil OS va qurilma har xil fayl tizimidan foydalanadi. Ularning cheklovlari real ahamiyatga ega (quyidagi raqamlar rasmiy hujjatlar va ishlab chiquvchilar ma'lumotidan):

Amaliy oqibat: 8 GB lik video faylni FAT32 formatdagi USB'ga ko'chirolmaysiz — "fayl juda katta" xatosi chiqadi, garchi USB'da 50 GB bo'sh joy bo'lsa ham! Sababi — FAT32'ning bitta fayl uchun 4 GB chegarasi. Yechim: USB'ni exFAT yoki NTFSga formatlash.

2.9. Fayl turlari va kengaytma (extension)

rasm.png, kod.js, hisobot.pdf — bu yerdagi .png, .js, .pdf — kengaytma (extension). Muhim haqiqat: kengaytma — shunchaki nom qismi, kelishuv. U faylning haqiqiy turini kafolatlamaydi.

Faylni rasm.png dan rasm.txt ga qayta nomlasangiz, ichidagi baytlar o'zgarmaydi — bu hali ham rasm. Faqat OS va dasturlar kengaytmaga qarab "buni qaysi dastur bilan ochaman?" deb taxmin qiladi. (Faylning haqiqiy turini ichidagi dastlabki baytlar — "magic number" — aytadi; buni file upload xavfsizligida, 5.11/14-boblarda ko'ramiz.)

2.10. Fayl ruxsatlari (permissions) — Unix modeli

Linux/macOS — ko'p foydalanuvchili (multi-user) tizimlar. Shuning uchun har bir fayl uchun kim nima qila olishi belgilanadi. Uch xil amal va uch xil toifa bor (Linux man-pages va Unix standartiga ko'ra):

Amallar (har biri 1 bit / harf):

• r (read) — o'qish = qiymati 4
• w (write) — yozish/o'zgartirish = qiymati 2
• x (execute) — ishga tushirish (papkada — ichiga kirish) = qiymati 1

Toifalar:

• owner (egasi / user) — faylni yaratgan odam
• group (guruh) — fayl tegishli guruh
• other (boshqalar) — qolgan hamma

ls -l buyrug'i ruxsatlarni shunday ko'rsatadi:

  -rwxr-xr-x
  │└┬┘└┬┘└┬┘
  │ │  │  └── other  : r-x  (o'qish + ishga tushirish)
  │ │  └───── group  : r-x  (o'qish + ishga tushirish)
  │ └──────── owner  : rwx  (o'qish + yozish + ishga tushirish)
  └────────── tur    : "-" fayl, "d" papka (directory)

Octal (sakkizlik) yozuv — har toifa uchun r=4, w=2, x=1 qo'shiladi:

Masalan 755 = owner 4+2+1=7, group 4+0+1=5, other 4+0+1=5. Ruxsatni o'zgartirish: chmod 644 fayl.txt (buni 0.3 Terminal bobida amalda ishlatamiz).

Diqqat: Windows ham ruxsatlarga ega (NTFS ACL), lekin modeli boshqacha. Server dunyosi Linux'da bo'lgani uchun, Unix ruxsatlari (rwx / octal) — har bir backend dasturchi bilishi shart bo'lgan bilim. SSH kalitingiz 600 bo'lmasa, server sizni umuman kiritmaydi — bu real, tez-tez uchraydigan holat (10.1-bob).

2.11. Asosiy OS oilalari

Xulosa: siz Windows yoki macOS'da yozasiz, lekin kodingiz Linuxda ishlaydi. Shuning uchun Linux va Unix fayl tizimini (path, ruxsatlar, harf registriga sezgirlik) bilish — zaruriyat, hashamat emas.

3. Sintaksis va asosiy belgilanishlar

Bu yerda ham "kod sintaksisi" emas, balki har kuni uchraydigan yozuvlarni o'qiy olish kerak.

Path yozuvlari:

/home/ali/loyiha/index.js      Unix absolute path
C:\Users\Ali\loyiha\index.js   Windows absolute path
./loyiha/index.js              relative: joriy papkadan
../rasm.png                    relative: ota papkadan
~/loyiha                       home papkadan (Unix)

Ruxsat (permission) yozuvlari:

rwxr-xr-x   ≡  755   (egasi: hammasi, qolganlar: o'qish+ishga tushirish)
rw-r--r--   ≡  644   (egasi: o'qish+yozish, qolganlar: o'qish)
rw-------   ≡  600   (faqat egasi)
drwxr-xr-x          "d" — bu papka (directory)

Yashirin (hidden) fayllar — Unix'da nomi . bilan boshlangan fayl yashirin hisoblanadi:

.gitignore   .env   .bashrc   .ssh/       yashirin (odatdagi `ls` ko'rsatmaydi)

4. Batafsil kod namunalari

Endi nazariyani Node.js bilan amalda ko'ramiz. Node platformalararo (cross-platform) ishlaydi va aynan shu OS xususiyatlarini boshqarish uchun maxsus modullarga ega: os, path, fs. (Bu kodlarni 0.7-bobda Node o'rnatib bo'lgach sinab ko'rasiz; hozir tushunib qo'yganingiz kifoya.)

Eslatma uslub haqida: Node'ning ichki (built-in) modullarini chaqirishning klassik usuli — require(...). Modullarni (import/export) 2.14-bobda chuqur ko'ramiz; hozir require yetarli.

Misol 1 — OS haqida ma'lumot olish (os moduli)

// "os" — operatsion tizim haqida ma'lumot beradigan ichki Node moduli.
const os = require("os");

console.log(os.platform());   // "win32" | "linux" | "darwin"(macOS)
console.log(os.arch());       // "x64" | "arm64" — protsessor arxitekturasi
console.log(os.cpus().length);// CPU yadrolari soni (0.1-dagi "core")
console.log(os.totalmem());   // jami RAM (baytlarda)
console.log(os.freemem());    // bo'sh RAM (baytlarda)
console.log(os.homedir());    // foydalanuvchi home papkasi (~)
console.log(os.tmpdir());     // vaqtinchalik fayllar papkasi

// RAM'ni odam o'qiydigan ko'rinishga o'tkazamiz (0.1-dagi baytdan GB):
const gb = os.totalmem() / 1024 ** 3;  // bayt -> GiB (1024^3)
console.log(`Jami RAM: ${gb.toFixed(2)} GiB`); // masalan "Jami RAM: 15.84 GiB"

Misol 2 — Path'ni TO'G'RI tuzish (path moduli)

const path = require("path");

//  path.join — bo'laklarni OS'ga MOS ajratuvchi bilan birlashtiradi.
// Windows'da "\", Linux'da "/" qo'yadi — biz o'ylab o'tirmaymiz.
const p = path.join("loyiha", "src", "index.js");
console.log(p); // Windows: "loyiha\src\index.js"  | Linux: "loyiha/src/index.js"

// path.resolve — relative path'ni ABSOLUTE path'ga aylantiradi
// (joriy papkadan boshlab to'liq manzil).
console.log(path.resolve("index.js")); // masalan "D:\loyiha\index.js"

// Path'ni bo'laklarga ajratish:
const fayl = "/home/ali/loyiha/index.js";
console.log(path.basename(fayl)); // "index.js"  — fayl nomi
console.log(path.dirname(fayl));  // "/home/ali/loyiha" — papka qismi
console.log(path.extname(fayl));  // ".js" — kengaytma
console.log(path.sep);            // OS ajratuvchisi: "\" yoki "/"

Misol 3 — Joriy papka tushunchasi (cwd vs __dirname)

// process.cwd() — dastur QAYERDAN ishga tushirilgani (joriy ish papkasi).
//   Bu — terminalda turgan joyingga bog'liq, o'zgaruvchan.
console.log(process.cwd()); // masalan "D:\Documents\Work"

// __dirname — joriy FAYLNING o'zi joylashgan papka. O'zgarmas.
console.log(__dirname);     // masalan "D:\Documents\Work\loyiha\src"

// XATO manbai: relative path "data.txt" — bu cwd'ga nisbatan qidiriladi,
// __dirname'ga emas! Shuning uchun fayl topilmasligi mumkin.
// To'g'risi — faylni __dirname'ga bog'lash:
const path = require("path");
const dataPath = path.join(__dirname, "data.txt"); // ishonchli absolute path
console.log(dataPath);

Misol 4 — Fayl/papka haqida ma'lumot (fs moduli)

const fs = require("fs");
const path = require("path");

const papka = process.cwd(); // joriy papkani tekshiramiz

// readdirSync — papka ichidagi nom ro'yxatini massiv qilib qaytaradi.
const nomlar = fs.readdirSync(papka);

for (const nom of nomlar) {
  const toliq = path.join(papka, nom);

  // statSync — fayl/papka haqidagi metadata (0.2.6-dagi metadata!).
  const info = fs.statSync(toliq);

  const turi = info.isDirectory() ? "[PAPKA]" : "[FAYL] ";
  const hajmKB = (info.size / 1024).toFixed(1); // bayt -> KiB

  console.log(`${turi} ${nom}  (${hajmKB} KB)`);
  // info.birthtime — yaratilgan sana; info.mtime — oxirgi o'zgartirilgan sana
}

// Fayl mavjudligini xavfsiz tekshirish:
console.log(fs.existsSync(path.join(papka, "package.json"))); // true/false

Misol 5 — Ruxsatni o'qish (Unix'da ma'noli)

const fs = require("fs");

const info = fs.statSync("./build.mjs");

// info.mode ichida ruxsat bitlari bor. Octal ko'rinishga o'tkazamiz.
// (& 0o777 — faqat ruxsat bitlarini ajratib olamiz)
const octal = (info.mode & 0o777).toString(8);
console.log("Ruxsat (octal):", octal); // Linux'da masalan "644" yoki "755"
// Windows'da bu model boshqacha bo'lgani uchun natija unchalik ma'noli emas;
// Linux serverda esa aynan shu — 2.10-dagi ruxsatlar.

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

1) Path'ni qo'lda, slash bilan yopishtirish

//  NOTO'G'RI — "\" Windows'da ishlaydi, Linux serverda buziladi
const p = "src" + "\\" + "index.js";

//  NOTO'G'RI — "/" ko'p joyda ishlaydi, lekin baribir qo'lda yozish — zaif
const p2 = "src" + "/" + "index.js";

//  TO'G'RI — path.join OS'ga mos ajratuvchini o'zi qo'yadi
const path = require("path");
const p3 = path.join("src", "index.js");

Nega: kod Windows'da yozilib, Linux'da ishlaydi. path moduli bu farqni siz uchun hal qiladi.

2) Harf registriga (case) e'tibor bermaslik

// Faylning haqiqiy nomi: Header.js
import Header from "./header.js"; // 

//  aynan to'g'ri registr bilan:
import Header from "./Header.js";

Nega: Windows va macOS fayl nomida katta-kichik harfni ko'pincha farqlamaydi (header.js ≡ Header.js). Linux esa farqlaydi — header.js va Header.js ikki xil fayl! Shuning uchun Windows'da ishlagan import Linux serverda Cannot find module beradi. Bu — eng mashhur "menda ishlaydi-ku!" bug'i.

3) Maxfiy fayllarni himoyasiz qoldirish

#  NOTO'G'RI — .env (parollar, kalitlar) git'ga tushib ketsa, hammaga ochiq
# (hech qanday himoya yo'q)

#  TO'G'RI — .gitignore ga qo'shish (4.5-bob) + Linux'da ruxsatni cheklash
.env
node_modules/
*.log

chmod 600 .env   #  faqat egasi o'qiy oladi (2.10)

4) Noto'g'ri fayl tizimiga katta fayl saqlash

 8 GB video    FAT32 USB    "fayl juda katta" (4 GB chegara)
 8 GB video    exFAT/NTFS USB    ishlaydi

6. Keng tarqalgan xatolar va yechimlari

Xato 1 — ENOENT: no such file or directory

Error: ENOENT: no such file or directory, open 'data.txt'

Sababi: fayl topilmadi. Eng ko'p sabab — relative path joriy papkaga (process.cwd()) nisbatan qidirilyapti, lekin siz kutgan joyda emas. Yechimi: path.join(__dirname, "data.txt") bilan ishonchli absolute path tuzish (Misol 3).

Xato 2 — EACCES: permission denied

Error: EACCES: permission denied, open '/etc/hosts'

Sababi: faylga yozish/o'qish ruxsatingiz yo'q 2.10-bob. Yechimi: ruxsatni to'g'rilash (chmod), egasini to'g'rilash (chown), yoki o'zingizga tegishli papkada ishlash. Linux serverda bu juda tez-tez uchraydi.

Xato 3 — EADDRINUSE: address already in use

Error: listen EADDRINUSE: address already in use :::3000

Sababi: 3000-port'ni boshqa process allaqachon band qilgan 2.4-bob. Yechimi: o'sha process'ni topib to'xtatish (lsof -i :3000 kill <PID> Linux'da; Windows'da netstat -ano | findstr :3000 taskkill), yoki boshqa port ishlatish.

Xato 4 — EISDIR / ENOTDIR

Error: EISDIR: illegal operation on a directory, read

Sababi: fayl kutilgan joyda papka bor (yoki aksincha — ENOTDIR). Yechimi: fs.statSync(p).isDirectory() bilan oldindan tekshirish (Misol 4).

Xato 5 — "menda ishlaydi, serverda yo'q"

Bu xato xabar emas, lekin eng ko'p vaqt yeydigan muammo. Sabablari odatda: (a) harf registri farqi (5-bo'lim, 2-holat), (b) path ajratuvchisi \ vs /, (c) Windows'da o'rnatilmagan kutubxona Linux'da boshqacha. Yechimi: path modulini ishlatish, registrga qat'iy rioya qilish va imkon bo'lsa Docker 10.3-bob bilan bir xil muhitda ishlash.

7. Integratsiya — bu mavzu stack'ning qayerida uchraydi

• Terminal 0.3-bob: keyingi bobda aynan shu fayl tizimi bo'ylab cd, ls, mkdir, chmod bilan harakatlanamiz.
• Node.js core modullar 5.3-bob: fs, path, os, process — shu bobda tanishganlarimiz chuqur ochiladi.
• Streams 5.4-bob: katta faylni system call'larni kamaytirib, bo'lak-bo'lak o'qish (2.3-dagi "mode switch qimmat").
• Event loop 5.1-bob: OS process'ni qanday rejalashtirishi 2.5-bob — Node asinxronligining negizi.
• Environment & dotenv 5.8-bob, .gitignore 4.5-bob: .env, maxfiy fayllar, ruxsatlar 2.10-bob.
• File upload 5.11-bob: yuklangan fayllar diskda qayerga tushadi, qanday nomlanadi, kengaytma xavfsizligi 2.9-bob.
• Docker 10.3-bob: konteyner — aslida Linux kernel'ning process va fayl tizimi izolyatsiyasi (namespaces) ustiga qurilgan (2.2, 2.4).
• Linux server, SSH, Nginx (10.1, 10.2): deploy — Linux fayl tizimi va ruxsatlar bilan to'g'ridan-to'g'ri ish (SSH kalit 600).
• Xavfsizlik (14): ruxsatlar, maxfiy fayllar, magic number bo'yicha fayl turini tekshirish.

8. Eng yaxshi amaliyotlar (best practices)

• Linux'ni o'rganing. Serverlarning deyarli hammasi Linux'da. Hech bo'lmaganda WSL (Windows Subsystem for Linux) yoki virtual mashinada Linux bilan ishlashga odatlaning.
• Path'ni hech qachon qo'lda yopishtirmang — doim path.join / path.resolve ishlating.
• Harf registriga qat'iy rioya qiling. Fayl Header.js bo'lsa, importda ham aynan Header.js. Bu Linux'da hayotingizni saqlaydi.
• Maxfiy fayllarni himoya qiling. .env va kalitlar .gitignoreda bo'lsin; Linux'da chmod 600.
• __dirname va process.cwd() farqini biling. Faylga murojaatda qaysi biri kerakligini ongli tanlang.
• To'g'ri fayl tizimini tanlang. Katta fayl uchun FAT32 emas, exFAT/NTFS.
• Loyiha tuzilmasini toza tuting. src/, public/, config/ kabi mantiqiy papkalar — kelajakda o'zingizga rahmat aytasiz.
• Xatolarni "kod" bo'yicha taning. ENOENT, EACCES, EADDRINUSE — bularni ko'rganda darrov sababini bilib oling (6-bo'lim).

9. Amaliy loyiha: "Papka Tahlilchisi (Disk Usage Analyzer)"

Fayl tizimi tushunchalarini mustahkamlash uchun amaliy va foydali CLI (buyruq qatori) dasturi — Node.js bilan, faqat ichki modullar (fs, path) yordamida.

Maqsad

Berilgan papkani rekursiv (ichidagi barcha papkalar bilan) skanerlab, u haqida foydali statistika chiqaradigan dastur yozish. Maqsad — fs va path bilan ishlashni, daraxtsimon tuzilmani 2.6-bob va metadata'ni (hajm, tur) amalda his qilish.

Talablar (requirements)

1. Dastur buyruq qatoridan papka yo'lini qabul qilsin (masalan node analyzer.js ./loyiha). Berilmasa — joriy papkani (process.cwd()) ishlatsin.
2. Papkani rekursiv aylanib chiqib, quyidagilarni hisoblasin:
   • jami fayllar soni va jami papkalar soni;
   • umumiy hajm (baytlarda, hamda odam o'qiydigan KB/MB/GB ko'rinishida);
   • kengaytma bo'yicha statistika: har bir .js, .png, .md ... uchun nechta fayl va jami necha bayt.
3. Eng katta 5 ta faylni (yo'li va hajmi bilan) ko'rsatsin.
4. (Bonus) Papka tuzilmasini daraxt ko'rinishida chop etsin (├──, │, └── belgilari bilan — yuqoridagi diagrammalardek).
5. node_modules va .git kabi papkalarni o'tkazib yuborish imkoni bo'lsin.

Maslahatlar (hint)

• fs.readdirSync(papka) — papka ichidagi nomlar; har biri uchun path.join(papka, nom) bilan to'liq yo'l tuzing.
• fs.statSync(toliq) .isDirectory(), .size. Papka bo'lsa — o'sha funksiyani o'zini ichki papkaga chaqiring (rekursiya — 3.11-bobda chuqur, hozir oddiy holati yetarli).
• Kengaytmani path.extname(nom) bilan oling; statistikani object (lug'at) yoki Map (2.9-bob) da yig'ing.
• Baytni odam o'qiydigan ko'rinishga o'tkazish uchun kichik funksiya yozing: 1024'dan bo'lib, B KB MB GB ga ko'tariling (0.1-dagi birliklar).
• Eng katta fayllar uchun barcha fayllarni {yo'l, hajm} ko'rinishida yig'ib, hajm bo'yicha sort qilib, slice(0, 5) oling (Array metodlari — 2.7).
• Buyruq qatori argumenti: process.argv[2] (0-chi va 1-chi — node va fayl yo'li).

"Tayyor" mezonlari (acceptance criteria)

• node analyzer.js <papka> ishlaydi; argument berilmasa joriy papkani oladi.
• Jami fayl/papka soni va umumiy hajm to'g'ri (qo'lda kichik papkada tekshirib ko'ring).
• Hajm odam o'qiydigan ko'rinishda chiqadi (masalan 15.3 MB, faqat baytda emas).
• Kengaytma bo'yicha statistika to'g'ri guruhlanadi.
• Eng katta 5 fayl to'g'ri tartibda chiqadi.
• node_modules/.git o'tkazib yuboriladi (aks holda juda sekin bo'ladi).
• Mavjud bo'lmagan papka berilsa, dastur qulamaydi — tushunarli xabar beradi (ENOENTni eslab, 6-bo'lim).

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

10. Xulosa va keyingi bobga ko'prik

Bu bobda temir bilan dastur o'rtasidagi boshqaruvchini o'rgandik:

• Operatsion tizim — resurslarni (CPU, RAM, disk) boshqaradi va dasturlarga qulay interfeys beradi.
• Kernel temirga to'liq teginadi; kernel space / user space ajratmasi xavfsizlik va barqarorlik uchun. Dasturingiz temirga system call orqali (mode switch bilan) murojaat qiladi.
• Process — o'z xotirali ishlayotgan dastur; thread — process ichidagi, xotirani baham ko'radigan oqim. Node — bitta asosiy thread (event loop'ning siri).
• Fayl tizimi diskni fayl (baytlar + metadata) va papka (daraxt) qilib tashkil etadi. Path absolute yoki relative bo'ladi; Windows \/C:, Unix /.
• Fayl tizimi turlari (FAT32 4 GB chegara, exFAT, NTFS, ext4) real cheklovlarga ega.
• Ruxsatlar (rwx / octal 755, 644, 600) — Unix ko'p foydalanuvchili xavfsizlik modeli; backend uchun majburiy bilim.
• Eng katta amaliy saboq: Windows'da yozasiz, Linux'da ishlaydi — path va harf registriga e'tibor bering.

Keyingi bob — 0.3-bob: Terminal / buyruq qatori (bash asoslari). Endi fayl tizimini bilamiz; navbat — uni qo'lda boshqarishga. Terminal — dasturchining eng kuchli quroli: cd, ls, mkdir, rm, chmod va undan keyin git, npm, docker — hammasi shu yerda yashaydi. Bu bobda o'rgangan path va ruxsatlar to'g'ridan-to'g'ri ishga tushadi.

Foydalanilgan rasmiy/ishonchli manbalar

Bu bob faktlari quyidagi manbalar asosida tekshirilgan:

• The Linux Kernel documentation — kernel/user space, system calls
• Linux man-pages (chmod(1), fork(2), execve(2)) va Red Hat / NERSC hujjatlari — fayl ruxsatlari (rwx, octal)
• NTFS.com, Microsoft hujjatlari — FAT32 / exFAT / NTFS cheklovlari
• ext4 va APFS rasmiy spetsifikatsiyalari — fayl tizimi hajm chegaralari