path va os — join, resolve, dirname, platform, cpus

~15 daq · Node.js · Core Modullar

Muammodan boshlaylik

Siz loyihada fayl yo'lini qo'lda yozdingiz:

const filePath = 'src/data/users.json';

Kompyuteringizda ishladi. Hamkasbingizga yubordingiz — u Windows da ishlatadi, sinadi. Sababi: Windows da papkalar \ bilan ajratiladi, Linux va macOS da / bilan. Siz / yozdingiz — Windows tushunmadi.

Yoki bunday holat:

const fullPath = folder + '/' + filename;

folder o'zgaruvchisi oxirida / bilan tugasa — src//users.json chiqadi. Tugamasa — to'g'ri. Buni har safar tekshirib o'tirish — noto'g'ri yondashuv.

path moduli aynan shu muammolarni hal qiladi. U fayl yo'llarini operatsion tizimdan qat'i nazar to'g'ri boshqaradi — siz / yoki \ haqida o'ylamaysiz.

path moduli nima?

path — Node.js ning o'rnatilgan moduli. Fayl va papka yo'llarini boshqarish uchun. Alohida o'rnatish shart emas — Node.js bilan birga keladi.

const path = require('path');

Ichida nima bor? Asosan funksiyalar to'plami: yo'llarni birlashtirish, ajratish, mutlaq yo'lga aylantirish. Har bir funksiya operatsion tizimni o'zi aniqlaydi va mos ajratuvchi ishlatadi.

path.join — yo'llarni birlashtirish

path.join bir nechta qismni birlashtirib, to'g'ri yo'l hosil qiladi. Ortiqcha / larni tozalaydi. Operatsion tizimga mos ajratuvchi ishlatadi.

Qo'lda birlashtirish bilan farqi:

'src' + '/' + 'data' + '/' + 'users.json'
→ 'src/data/users.json'  ← Linux da ishlaydi, Windows da sinadi

path.join('src', 'data', 'users.json')
→ Linux/macOS: 'src/data/users.json'
→ Windows:     'src\data\users.json'

Ikkinchisi har qayerda ishlaydi. Birinchisi — faqat Linux da.

const path = require('path');

path.join('src', 'data', 'users.json');
// 'src/data/users.json'

path.join('src/', '/data/', '/users.json');
// 'src/data/users.json'  ← ortiqcha / lar tozalandi

path.join('src', '..', 'config');
// 'config'  ← .. bir yuqoriga chiqdi, src bekor bo'ldi

path.resolve — mutlaq yo'l

path.join nisbiy yo'l beradi — ya'ni hozirgi papkaga nisbatan. path.resolve esa to'liq, mutlaq yo'l beradi — diskdan boshlab.

Tasavvur qiling: siz config.json faylini topmoqchisiz. path.join('config.json') — bu nisbiy yo'l, qaysi papkadan ishga tushirilganiga bog'liq. path.resolve('config.json') — hozirgi ishchi papkadan boshlab to'liq yo'l beradi.

// Faraz qiling: hozirgi papka /home/user/project

path.resolve('src', 'index.js');
// '/home/user/project/src/index.js'

path.resolve('..', 'other-project');
// '/home/user/other-project'  ← bir yuqoriga chiqdi

path.resolve('/etc', 'nginx.conf');
// '/etc/nginx.conf'  ← mutlaq yo'l berilsa, undan boshlanadi

Oxirgi misol muhim: path.resolve ga mutlaq yo'l berilsa — undan oldingi hamma narsa e'tiborga olinmaydi. Chunki mutlaq yo'l diskdan boshlanadi, oldingi qismlar keraksiz.

join va resolve qachon ishlatiladi?

Faqat qismlarni birlashtirish kerak bo'lsa — join. Mutlaq yo'l kerak bo'lsa, yoki hozirgi papkadan hisoblash kerak bo'lsa — resolve.

__dirname — eng ko'p ishlatiladigan narsa

__dirname — CommonJS da avtomatik mavjud o'zgaruvchi. Hozirgi faylning papkasini ko'rsatadi. To'liq, mutlaq yo'l.

// Fayl: /home/user/project/src/app.js

console.log(__dirname);
// '/home/user/project/src'

console.log(__filename);
// '/home/user/project/src/app.js'

Nima uchun bu muhim? Fayl yo'llarini hisoblashda __dirname ishlatmasangiz — loyihani boshqa papkadan ishga tushirganda yo'llar noto'g'ri bo'ladi.

// Xavfli — qaysi papkadan ishga tushirilganiga bog'liq:
const configPath = path.join('config', 'db.json');

// Xavfsiz — har doim faylning o'z papkasiga nisbatan:
const configPath = path.join(__dirname, '..', 'config', 'db.json');
// /home/user/project/config/db.json
// Qayerdan ishga tushirilishidan qat'i nazar — har doim to'g'ri

⚠️ ES Modules (import/export) da __dirname mavjud emas. O'rniga:

import { fileURLToPath } from 'url';
import { dirname } from 'path';

const __filename = fileURLToPath(import.meta.url);
const __dirname  = dirname(__filename);

Bu biroz uzun, lekin bir marta yoziladi va qayta ishlatiladi.

path.basename, path.extname, path.dirname

Ba'zan yo'ldan faqat fayl nomi, kengaytmasi yoki papkasi kerak bo'ladi. Buning uchun uchta funksiya:

const filePath = '/home/user/project/src/app.js';

path.basename(filePath);          // 'app.js'                    ← fayl nomi
path.basename(filePath, '.js');   // 'app'                       ← kengaytmasiz nom
path.extname(filePath);           // '.js'                       ← kengaytma
path.dirname(filePath);           // '/home/user/project/src'    ← papka

Amaliy misol — fayllar ro'yxatidan faqat .js fayllarni olish:

const files = ['app.js', 'style.css', 'index.js', 'README.md'];

const jsFiles = files.filter(f => path.extname(f) === '.js');
// ['app.js', 'index.js']

path.parse va path.format

path.parse yo'lni barcha qismlariga ajratadi:

path.parse('/home/user/project/src/app.js');
// {
//   root: '/',
//   dir:  '/home/user/project/src',
//   base: 'app.js',
//   ext:  '.js',
//   name: 'app'
// }

path.format esa teskarisi — qismlardan yo'l yig'adi. Masalan, faylning kengaytmasini o'zgartirish:

const parsed = path.parse('/src/app.js');
parsed.ext  = '.ts';
parsed.base = 'app.ts'; // base ham o'zgartirilishi kerak

path.format(parsed);
// '/src/app.ts'

os moduli nima?

os — operatsion tizim haqida ma'lumot beruvchi modul. Server qanday mashina ekanini bilish kerak bo'lganda ishlatiladi: nechta protsessor bor, qancha xotira, qaysi platforma.

Bu ma'lumotlar qachon kerak? Masalan, cluster modulida nechta worker process yaratish kerakligini bilish uchun — CPU core soni kerak. Yoki monitoring tizimida serverning holati haqida ma'lumot yig'ish uchun.

const os = require('os');

os.platform va os.arch

os.platform() — operatsion tizim nomi. os.arch() — protsessor arxitekturasi.

os.platform(); // 'linux', 'darwin' (macOS), 'win32'
os.arch();     // 'x64', 'arm64'

Bu ko'pincha platformaga qarab boshqacha xatti-harakat qilish uchun ishlatiladi. Masalan, ba'zi CLI asboblar Windows da boshqacha buyruq ishlatadi.

os.cpus va xotira

os.cpus() — har bir CPU core haqida massiv qaytaradi. Massivning uzunligi — core soni.

os.cpus().length;    // 8  ← 8 ta core bor
os.cpus()[0].model;  // 'Intel(R) Core(TM) i7-9750H'

Nima uchun core soni muhim? cluster modulida optimal worker soni — CPU core soni bilan teng. Kamroq bo'lsa — resurslar to'liq ishlatilmaydi. Ko'proq bo'lsa — foyda yo'q, aksincha overhead.

const workerCount = os.cpus().length; // 8 core → 8 worker

Xotira:

os.totalmem(); // 17179869184  ← baytda (16 GB)
os.freemem();  // 4294967296   ← bo'sh xotira

// Odam o'qiydigan ko'rinishda:
const totalGB = (os.totalmem() / 1024 ** 3).toFixed(1); // '16.0'
const freeGB  = (os.freemem()  / 1024 ** 3).toFixed(1); // '4.0'
console.log(`${freeGB} GB bo'sh / ${totalGB} GB jami`);

os.homedir va os.tmpdir

os.homedir() — foydalanuvchining uy papkasi. Linux da /home/user, Windows da C:\Users\user.

os.tmpdir() — vaqtinchalik fayllar uchun tizim papkasi. Linux da /tmp.

Vaqtinchalik fayllarni os.tmpdir() ga yozish — yaxshi amaliyot. Tizim o'zi tozalaydi, loyiha papkasi ifloslanmaydi.

const tempFile = path.join(os.tmpdir(), 'my-app-cache.json');
// '/tmp/my-app-cache.json'

os.hostname va os.uptime

os.hostname(); // 'my-server-01'  ← server nomi
os.uptime();   // 86400  ← server necha soniya ishlab turibdi (1 kun = 86400 s)

Logging da foydali — bir nechta server bo'lsa, qaysi serverdan log kelganini bilish uchun os.hostname() qo'shiladi.

Tez-tez uchraydigan xatolar

ES Modules da __dirname ishlatish:

// package.json da "type": "module" bo'lsa — bu xato:
console.log(__dirname);
// ReferenceError: __dirname is not defined

Sababi: ES Modules da __dirname avtomatik yaratilmaydi. Yuqoridagi fileURLToPath yechimini ishlatish kerak.

path.resolve ga mutlaq yo'l berish:

path.resolve('/foo', '/bar', 'baz');
// '/bar/baz'  ← '/foo' e'tiborga olinmadi!

path.resolve argumentlarni o'ngdan chapga qarab ko'radi. Mutlaq yo'lga duch kelsa — undan oldingi hamma narsa tashlanadi. Bu kutilmagan natija berishi mumkin.

String birlashtirish bilan yo'l yasash:

const p = __dirname + '/' + 'config.json';
// Windows da sinadi — \ kerak edi

Har doim path.join(__dirname, 'config.json') ishlatiladi.

Xulosa

path moduli fayl yo'llarini operatsion tizimdan qat'i nazar to'g'ri boshqaradi. Asosiy qoida: yo'llarni hech qachon qo'lda birlashtirmang — path.join yoki path.resolve ishlatiladi. __dirname esa faylning o'z papkasini ko'rsatadi va yo'l hisoblashda har doim ishlatiladi.

os moduli server haqida ma'lumot beradi. Amalda ko'proq os.cpus().length (worker soni uchun) va os.tmpdir() (vaqtinchalik fayllar uchun) ishlatiladi.

Keyingi dars

12-dars: fs — readFile, writeFile, mkdir, unlink