Path moduli
Yo‘l moduli nima?
Path moduli o‘rnatilgan Node.js moduli bo‘lib, u turli xil operatsion tizimlarda fayl yo‘llarini qayta ishlash va o‘zgartirish uchun vositalarni taqdim etadi.
Windows teskari slesh (\), POSIX tizimlari (Linux, macOS) esa oddiy slesh (/) ishlatgani uchun Path moduli istalgan tizimda to‘g‘ri ishlaydigan kross-platforma kod yozishga yordam beradi.
Asosiy imtiyozlar:
- O‘zaro platforma yo‘llarini boshqarish
- Yo‘lni manipulyatsiya qilish va normallashtirish
- Oson fayl kengaytmasini olish
- Yo‘lni aniqlash va qo‘shilish
- Nisbiy va mutlaq yo‘llar bilan ishlash
Yo‘l modulidan foydalanish
Path moduli Node.js-ning asosiy modulidir, shuning uchun uni o‘rnatish shart emas.
Siz uni CommonJS yoki ES modullari sintaksisi yordamida import qilishingiz mumkin:
CommonJS (Node.js’da standart)
const path = require('path');
// Destructure specific methods if needed
const { join, resolve, basename } = require('path');
ES modullari ("turi" bilan Node.js 14+: package.json ichidagi "modul")
import path from 'path';
// Or import specific methods
import { join, resolve, basename } from 'path';
Eng yaxshi amaliyot: Daraxtlarni yaxshiroq silkitish va kichikroq to‘plam o‘lchamlari uchun ES modullaridan foydalanganda faqat kerakli usullarni import qiling.
Yo‘l moduli usullari
path.basename()
Unix basename buyrug‘iga o‘xshash yo‘lning oxirgi qismini qaytaradi.
const path = require('path');
// Get filename from a path
const filename = path.basename('/users/docs/file.txt');
console.log(filename);
// Get filename without extension
const filenameWithoutExt = path.basename('/users/docs/file.txt', '.txt');
console.log(filenameWithoutExt);
O‘zingiz sinab ko‘ring »
__dirname va __fayl nomi
Node.js da __dirname va __filename CommonJS modullarida mavjud bo‘lgan maxsus o‘zgaruvchilar bo‘lib, ular joriy modulning katalog nomi va fayl nomini ta’minlaydi.
Misol: CommonJS da __dirname va __filename dan foydalanish
// CommonJS module (e.g., app.js)
const path = require('path');
// Get the directory name of the current module
console.log('Directory name:', __dirname);
// Get the file name of the current module
console.log('File name:', __filename);
// Building paths relative to the current module
const configPath = path.join(__dirname, 'config', 'app-config.json');
console.log('Config file path:', configPath);
// Getting the directory name using path.dirname()
console.log('Directory using path.dirname():', path.dirname(__filename));
O‘zingiz sinab ko‘ring »
Misol: ES modullarida __dirname va __fayl nomini olish
// ES Module (e.g., app.mjs or "type": "module" in package.json)
import { fileURLToPath } from 'url';
import { dirname } from 'path';
// Get the current module's URL
const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);
console.log('ES Module file path:', __filename);
console.log('ES Module directory:', __dirname);
// Example with dynamic imports
async function loadConfig() {
const configPath = new URL('../config/app-config.json', import.meta.url);
const config = await import(configPath, { with: { type: 'json' } });
return config;
}
Misolni ishga tushirish »
Eng yaxshi amaliyotlar:
- CommonJS modullarida fayl yo‘llarini yaratish uchun
path.join()yokipath.resolve()dan__dirnamebilan foydalaning. - ES modullari uchun ekvivalent funksiyani olish uchun
import.meta.urldanfileURLToPathvadirnamedan foydalaning. __dirnamedanpath.join()bilan foydalanilganda, to‘g‘ri platforma ajratuvchisiga normallashtiriladigan qiyshiq chiziqdan xavfsiz foydalanishingiz mumkin.
path.extname()
. belgisining oxirgi paydo bo‘lishidan string oxirigacha bo‘lgan yo‘lning kengaytmasini qaytaradi.
const path = require('path');
const extension = path.extname('file.txt');
console.log(extension);
console.log(path.extname('index.html'));
console.log(path.extname('index.coffee.md'));
console.log(path.extname('index.'));
console.log(path.extname('index'));
console.log(path.extname('.index'));
O‘zingiz sinab ko‘ring »
path.join()
Ajratuvchi sifatida platformaga xos ajratgich yordamida barcha berilgan yo‘l segmentlarini birlashtiradi, so‘ngra hosil bo‘lgan yo‘lni normallashtiradi.
Misol: Asosiy yo‘lni birlashtirish
const path = require('path');
// Join path segments
const fullPath = path.join('/users', 'docs', 'file.txt');
console.log(fullPath); // Output depends on OS
// Handle relative paths and navigation
console.log(path.join('/users', '../system', './logs', 'file.txt'));
// Handle multiple slashes
console.log(path.join('users', '//docs', 'file.txt')); // Normalizes slashes
O‘zingiz sinab ko‘ring »
Eslatma: path.join() + bilan stringlarni birlashtirishdan afzalroq, chunki u operatsion tizimlar bo‘ylab turli yo‘l ajratgichlarni boshqaradi.
path.resolve()
Yo‘llar yoki yo‘l segmentlari ketma-ketligini mutlaq yo‘lga aylantiradi, mutlaq yo‘l tuzilmaguncha o‘ngdan chapga ishlov beradi.
Misol: Yo‘llarni hal qilish
const path = require('path');
// 1. Resolve relative to current working directory
console.log(path.resolve('file.txt'));
// 2. Resolve with multiple segments
console.log(path.resolve('/users', 'docs', 'file.txt'));
// 3. Right-to-left processing
console.log(path.resolve('/first', '/second', 'third')); // '/second/third'
// 4. Using __dirname for module-relative paths
console.log(path.resolve(__dirname, 'config', 'app.json'));
O‘zingiz sinab ko‘ring »
Maslahat: path.resolve() odatda joriy modul joylashgan joyga nisbatan mutlaq yo‘llarni yaratish uchun __dirname bilan qo‘llaniladi.
path.parse()
Xususiyatlari yo‘lning muhim elementlarini ifodalovchi obyektni qaytaradi.
Misol: fayl yo‘lini tahlil qilish
const path = require('path');
// Parse a file path
const pathInfo = path.parse('/users/docs/file.txt');
console.log(pathInfo);
/* Output on Unix/macOS:
{
root: '/',
dir: '/users/docs',
base: 'file.txt',
ext: '.txt',
name: 'file'
}
*/
// Accessing parsed components
console.log('Directory:', pathInfo.dir); // /users/docs
console.log('Filename:', pathInfo.base); // file.txt
console.log('Name only:', pathInfo.name); // file
console.log('Extension:', pathInfo.ext); // .txt
O‘zingiz sinab ko‘ring »
Eslatma: path.parse() chiqishi yo‘lni qayta qurish uchun path.format() ga o‘tkazilishi mumkin.
path.format()
Obyektdan path.parse() ga qarama-qarshi bo‘lgan yo‘l stringini qaytaradi.
Misol: yo‘l obyektlarini formatlash
const path = require('path');
// Method 1: Using dir and base
const pathString1 = path.format({
dir: '/users/docs',
base: 'file.txt'
});
console.log(pathString1); // '/users/docs/file.txt'
// Method 2: Using root, dir, name, and ext
const pathString2 = path.format({
root: '/',
dir: '/users/docs',
name: 'file',
ext: '.txt'
});
console.log(pathString2); // '/users/docs/file.txt'
// Practical example: Modify and reconstruct a path
const parsedPath = path.parse('/users/docs/old-file.txt');
parsedPath.base = 'new-file.md';
const newPath = path.format(parsedPath);
console.log(newPath); // '/users/docs/new-file.md'
O‘zingiz sinab ko‘ring »
Eslatma: path.format() dan foydalanilganda, dir va root xususiyatlari taqdim etilsa, root hisobga olinmaydi.
path.normalize()
Berilgan yo‘lni normallashtiradi, .. va . segmentlarini hal qiladi va ortiqcha ajratgichlarni olib tashlaydi.
Misol: yo‘llarni normallashtirish
const path = require('path');
// Resolve relative navigation
console.log(path.normalize('/users/./docs/../data/file.txt')); // '/users/data/file.txt'
// Handle multiple consecutive slashes
console.log(path.normalize('/users//docs////file.txt')); // '/users/docs/file.txt'
// Windows-style paths (automatically handled)
console.log(path.normalize('C:\\users\\docs\\..\\file.txt')); // 'C:\\users\\file.txt'
// Edge cases
console.log(path.normalize('')); // '.'
console.log(path.normalize('.')); // '.'
console.log(path.normalize('..')); // '..'
console.log(path.normalize('/..')); // '/'
O‘zingiz sinab ko‘ring »
Xavfsizlik eslatmasi: path.normalize() .. ketma-ketlikni hal qilsa-da, u kataloglar bo‘ylab hujumlardan himoya qilmaydi. Fayl yo‘llari bilan ishlashda har doim foydalanuvchi ma’lumotlarini tekshiring va tozalang.
path.relative()
Birinchi yo‘ldan ikkinchi yo‘lga nisbiy yo‘lni yoki yo‘llar bir xil bo‘lsa, bo‘sh stringni qaytaradi.
Misol: Nisbiy yo‘llarni topish
const path = require('path');
// Basic relative path
console.log(path.relative('/users/docs/file.txt', '/users/images/photo.jpg'));
// Output: '../../images/photo.jpg'
// Same directory
console.log(path.relative('/users/docs/file1.txt', '/users/docs/file2.txt'));
// Output: 'file2.txt'
// Same file
console.log(path.relative('/users/docs/file.txt', '/users/docs/file.txt'));
// Output: ''
// Different roots (Windows)
console.log(path.relative('C:\\user\\test\\aaa', 'C:\\user\\impl\\bbb'));
// Output: '..\\..\\impl\\bbb'
// Practical example: Creating a relative path for web
const absolutePath = '/var/www/static/images/logo.png';
const webRoot = '/var/www/';
const webPath = path.relative(webRoot, absolutePath).replace(/\\/g, '/');
console.log(webPath); // 'static/images/logo.png'
O‘zingiz sinab ko‘ring »
Maslahat: path.relative(), ayniqsa, nisbiy URL manzillarini yaratish yoki loyihangizdagi turli joylar o‘rtasida ko‘chma yo‘llarni yaratish kerak bo‘lganda foydalidir.
path.isAbsolute()
Berilgan yo‘l mutlaq yo‘l ekanligini aniqlaydi. Mutlaq yo‘l, ishchi katalogdan qat’i nazar, har doim bir xil joyga o‘tadi.
Misol: Mutlaq yo‘llarni tekshirish
const path = require('path');
// POSIX (Unix/Linux/macOS)
console.log(path.isAbsolute('/users/docs')); // true
console.log(path.isAbsolute('users/docs')); // false
// Windows
console.log(path.isAbsolute('C:\\temp')); // true
console.log(path.isAbsolute('temp')); // false
// UNC paths (Windows network paths)
console.log(path.isAbsolute('\\\\server\\share')); // true
// Practical example: Ensure absolute path for config files
function ensureAbsolute(configPath) {
return path.isAbsolute(configPath)
? configPath
: path.resolve(process.cwd(), configPath);
}
console.log(ensureAbsolute('config.json')); // Resolves to absolute path
console.log(ensureAbsolute('/etc/app/config.json')); // Already absolute
O‘zingiz sinab ko‘ring »
Eslatma: Windows tizimida haydovchi harfi va undan keyin ikki nuqta qo‘yiladigan yo‘llar (masalan, 'C:\\') UNC yo‘llari (masalan, '\\\\server\\share') kabi mutlaq hisoblanadi.
Yo‘l xususiyatlari
yo‘l.sep
Platformaga xos yo‘l segmentini ajratuvchini ta’minlaydi.
Bu joriy operatsion tizim uchun standart yo‘l segmentini ajratuvchisini qaytaradigan faqat o‘qish uchun xususiyatdir.
Misol: Yo‘l ajratgichlar bilan ishlash
const path = require('path');
// Get the platform-specific separator
console.log(`Path separator: ${JSON.stringify(path.sep)}`); // '\\' on Windows, '/' on POSIX
// Building paths safely across platforms
const parts = ['users', 'docs', 'file.txt'];
const filePath = parts.join(path.sep);
console.log('Built path:', filePath);
// Splitting paths correctly
const pathToSplit = process.platform === 'win32'
? 'C:\\Users\\docs\\file.txt'
: '/users/docs/file.txt';
const pathParts = pathToSplit.split(path.sep);
console.log('Split path:', pathParts);
// Normalizing paths with the correct separator
const normalized = path.normalize(`users${path.sep}docs${path.sep}..${path.sep}file.txt`);
console.log('Normalized path:', normalized);
O‘zingiz sinab ko‘ring »
Eng yaxshi amaliyot: Node.js ilovalaringizda platformalararo muvofiqlikni ta’minlash uchun qattiq kodlash yo‘l ajratgichlari o‘rniga har doim path.sep dan foydalaning.
yo‘l.ajratish
PATH kabi muhit o‘zgaruvchilaridagi yo‘llarni ajratish uchun foydalaniladigan platformaga xos yo‘l chegaralagichini taqdim etadi.
Misol: PATH muhit o‘zgaruvchisi bilan ishlash
const path = require('path');
// Get the platform-specific delimiter
console.log(`Path delimiter: ${JSON.stringify(path.delimiter)}`); // ';' on Windows, ':' on POSIX
// Working with PATH environment variable
function findInPath(executable) {
if (!process.env.PATH) return null;
// Split PATH into directories
const pathDirs = process.env.PATH.split(path.delimiter);
// Check each directory for the executable
for (const dir of pathDirs) {
try {
const fullPath = path.join(dir, executable);
require('fs').accessSync(fullPath, require('fs').constants.X_OK);
return fullPath;
} catch (err) {
// File not found or not executable
continue;
}
}
return null;
}
// Example: Find node executable in PATH
const nodePath = findInPath(process.platform === 'win32' ? 'node.exe' : 'node');
console.log('Node.js path:', nodePath || 'Not found in PATH');
O‘zingiz sinab ko‘ring »
Eslatma: path.delimiter asosan PATH yoki NODE_PATH kabi bir nechta yo‘llarni o‘z ichiga olgan muhit o‘zgaruvchilari bilan ishlash uchun ishlatiladi.
path.win32
Ishlayotgan operatsion tizimingizdan qat’i nazar, Windows uslubidagi yo‘llar bilan ishlash imkonini beruvchi Windows-ga xos yo‘l usullariga kirishni ta’minlaydi.
Misol: Har qanday platformada Windows yo‘llari bilan ishlash
const path = require('path');
// Always use Windows-style path handling
const winPath = 'C:\\Users\\user\\Documents\\file.txt';
console.log('Windows basename:', path.win32.basename(winPath));
console.log('Windows dirname:', path.win32.dirname(winPath));
// Normalize Windows paths
console.log('Normalized path:', path.win32.normalize('C:\\\\temp\\\\foo\\..\\bar\\file.txt'));
// Convert between forward and backward slashes
const mixedPath = 'C:/Users/User/Documents//file.txt';
console.log('Normalized mixed slashes:', path.win32.normalize(mixedPath));
// Working with UNC paths
const uncPath = '\\\\server\\share\\folder\\file.txt';
console.log('UNC path components:', path.win32.parse(uncPath));
O‘zingiz sinab ko‘ring »
Use Case: path.win32 obyekti, ayniqsa, ilovangiz Windows tizimi jurnalidan yoki konfiguratsiya faylidan yo‘llarni qayta ishlashda, masalan, Windows bo‘lmagan platformalarda Windows uslubidagi yo‘llar bilan ishlashi kerak bo‘lganda foydalidir.
path.posix
POSIX-mos keladigan yo‘l usullariga kirishni ta’minlaydi, barcha platformalarda oldinga siljish yo‘lining izchil ishlashini ta’minlaydi.
Misol: har qanday platformada POSIX yo‘llari bilan ishlash
const path = require('path');
// Always use POSIX-style path handling
const posixPath = '/home/user/documents/file.txt';
console.log('POSIX basename:', path.posix.basename(posixPath));
console.log('POSIX dirname:', path.posix.dirname(posixPath));
// Normalize POSIX paths
console.log('Normalized path:', path.posix.normalize('/usr/local//bin/../lib/file.txt'));
// Working with relative paths
console.log('Relative path:', path.posix.relative('/data/test/aaa', '/data/impl/bbb'));
// Joining paths with POSIX separators
const urlPath = ['static', 'images', 'logo.png'].join(path.posix.sep);
console.log('URL path:', urlPath); // 'static/images/logo.png'
O‘zingiz sinab ko‘ring »
Use Case: path.posix obyekti, ayniqsa, veb-ilovalar, konfiguratsiya fayllari uchun yo‘llarning izchil ishlashini ta’minlash kerak bo‘lganda yoki asosiy operatsion tizimdan qat’i nazar, POSIX uslubidagi yo‘llarni kutadigan API bilan ishlashda foydalidir.
Umumiy foydalanish holatlari va eng yaxshi amaliyotlar
Modul yo‘llari bilan ishlash
Modul yo‘llarini tushunish va ular bilan ishlash xizmat ko‘rsatish mumkin bo‘lgan Node.js ilovalarini yaratish uchun juda muhimdir. Haqiqiy stsenariylarda yo‘lni boshqarish bo‘yicha ba’zi umumiy namunalar va eng yaxshi amaliyotlar.
Misol: Modul yo‘lining aniqligi
const path = require('path');
const fs = require('fs/promises') ;
// Current module's directory and file info
console.log('Module directory:', __dirname);
console.log('Module file path:', __filename);
// Common path patterns
const paths = {
// Configuration files relative to project root
config: path.join(__dirname, '..', 'config', 'app.json'),
// Logs directory (create if doesn't exist)
logs: path.join(__dirname, '..', 'logs'),
// Public assets
public: path.join(__dirname, '..', 'public'),
// Uploads directory with proper permissions
uploads: path.join(__dirname, '..', 'uploads')
};
// Ensure directories exist
async function ensureDirectories() {
try {
await Promise.all([
fs.mkdir(paths.logs, { recursive: true }),
fs.mkdir(paths.public, { recursive: true }),
fs.mkdir(paths.uploads, { recursive: true, mode: 0o755 })
]);
console.log('All directories ready');
} catch (error) {
console.error('Error creating directories:', error);
}
}
// Example: Load configuration
async function loadConfig() {
try {
const configData = await fs.readFile(paths.config, 'utf8');
return JSON.parse(configData);
} catch (error) {
console.error('Error loading config:', error.message);
return {};
}
}
// Example: Log to application log
async function logToFile(message) {
try {
const logFile = path.join(paths.logs, `${new Date().toISOString().split('T')[0]}.log`);
const logMessage = `[${new Date().toISOString()}] ${message}\n`;
await fs.appendFile(logFile, logMessage, 'utf8');
} catch (error) {
console.error('Error writing to log:', error);
}
}
// Initialize and run examples
(async () => {
await ensureDirectories();
const config = await loadConfig();
console.log('Loaded config:', config);
await logToFile('Application started');
})();
ES modullari yo‘lini boshqarish
ECMAScript modullarida (.mjs kengaytmali fayllar yoki package.json da "type": "module" o‘rnatilganda) __dirname va __filename mavjud emas. ES modullarida yo‘llarni qanday boshqarish mumkin:
// ES Module (app.mjs or with "type": "module" in package.json)
import { fileURLToPath } from 'url';
import { dirname, join } from 'path';
import { promises as fs } from 'fs';
// Get current module's directory and file path
const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);
// Utility function for path resolution in ES modules
function resolvePath(relativePath) {
return new URL(relativePath, import.meta.url).pathname;
}
// Example usage
const configPath = join(__dirname, '..', 'config', 'settings.json');
const assetPath = resolvePath('../assets/logo.png');
// Dynamic imports with paths relative to current module
async function loadModule(modulePath) {
const fullPath = new URL(modulePath, import.meta.url);
return import(fullPath);
}
Asosiy fikrlar:
- Joriy modulning URL manzilini olish uchun
import.meta.urldan foydalaning - Zarur bo‘lganda URLni
fileURLToPath()bilan fayl yo‘liga aylantiring - Yo‘lni aniqlash uchun asos sifatida
import.meta.urlbilanURLkonstruktoridan foydalaning - Platformalararo muvofiqlik uchun
path.join()va boshqa yo‘l usullaridan foydalanishda davom eting
Kengaytirilgan yo‘lni boshqarish naqshlari
Haqiqiy ilovalarda yo‘llar bilan ishlash uchun ba’zi ilg‘or naqshlar.
Misol: Ishlab chiqarish ilovalari uchun Path Utilities
const path = require('path');
const fs = require('fs/promises');
const os = require('os');
// Path utility class
class PathUtils {
static get tempDir() {
return path.join(os.tmpdir(), 'myapp');
}
static get userHome() {
return process.env.HOME || process.env.USERPROFILE || os.homedir();
}
static async ensureDirectory(dirPath) {
try {
await fs.mkdir(dirPath, { recursive: true, mode: 0o755 });
return true;
} catch (error) {
if (error.code !== 'EEXIST') throw error;
return false;
}
}
static isSafePath(baseDir, targetPath) {
const normalizedBase = path.resolve(baseDir);
const normalizedTarget = path.resolve(targetPath);
return normalizedTarget.startsWith(normalizedBase);
}
static getUniqueFilename(dir, filename) {
const { name, ext } = path.parse(filename);
let counter = 1;
let candidate = filename;
while (fs.existsSync(path.join(dir, candidate))) {
candidate = `${name} (${counter++})${ext}`;
}
return candidate;
}
}
// Example usage
(async () => {
// Ensure temp directory exists
await PathUtils.ensureDirectory(PathUtils.tempDir);
// Safe file operations
const userUploads = path.join(PathUtils.userHome, 'uploads');
const safePath = path.join(userUploads, 'profile.jpg');
if (PathUtils.isSafePath(userUploads, safePath)) {
console.log('Path is safe for operations');
} else {
console.error('Potential path traversal attack detected!');
}
// Generate unique filename
const uniqueName = PathUtils.getUniqueFilename(
userUploads,
'document.pdf'
);
console.log('Unique filename:', uniqueName);
// Working with file extensions
const filePath = '/users/john/docs/report.pdf';
const fileInfo = {
name: path.basename(filePath, path.extname(filePath)),
ext: path.extname(filePath),
dir: path.dirname(filePath)
};
console.log('File info:', fileInfo);
})();
Xavfsizlik masalalari
Fayl yo‘llari bilan ishlashda xavfsizlik har doim birinchi o‘rinda turishi kerak. Mana bir nechta muhim xavfsizlik masalalari va eng yaxshi amaliyotlar:
Misol: Xavfsiz yo‘lni boshqarish
const path = require('path');
const fs = require('fs').promises;
// 1. Prevent directory traversal attacks
function safeJoin(base, ...paths) {
const targetPath = path.join(base, ...paths);
const normalizedPath = path.normalize(targetPath);
// Ensure the resulting path is still within the base directory
if (!normalizedPath.startsWith(path.resolve(base))) {
throw new Error('Access denied: Path traversal detected');
}
return normalizedPath;
}
// 2. Validate file extensions
const ALLOWED_EXTENSIONS = new Set(['.jpg', '.jpeg', '.png', '.gif']);
function hasValidExtension(filePath) {
const ext = path.extname(filePath).toLowerCase();
return ALLOWED_EXTENSIONS.has(ext);
}
// 3. Safe file operations
async function safeReadFile(baseDir, relativePath) {
const safePath = safeJoin(baseDir, relativePath);
// Additional security checks
if (!hasValidExtension(safePath)) {
throw new Error('Invalid file type');
}
const stats = await fs.stat(safePath);
if (!stats.isFile()) {
throw new Error('Not a file');
}
return fs.readFile(safePath, 'utf8');
}
// Example usage
(async () => {
const UPLOAD_DIR = path.join(process.cwd(), 'uploads');
const userInput = '../../../etc/passwd'; // Malicious input
try {
// This will throw an error due to path traversal attempt
const content = await safeReadFile(UPLOAD_DIR, userInput);
console.log('File content:', content);
} catch (error) {
console.error('Security error:', error.message);
}
})();
Xavfsizlik bo‘yicha eng yaxshi amaliyotlar:
- Har doim foydalanuvchi tomonidan taqdim etilgan yo‘llarni tekshiring va tozalang
- Katalogga o‘tishni oldini olish uchun
path.normalize()dan foydalaning - To‘g‘ri fayl turini tekshirishni amalga oshiring
- Tegishli fayl ruxsatlarini o‘rnating
- Eng kam imtiyoz tamoyilidan foydalaning
eslint-plugin-securitykabi xavfsizlik linteridan foydalanishni o‘ylab ko‘ring
Platformalararo ishlab chiqish
O‘zaro platforma ilovalarini ishlab chiqishda, operatsion tizimlar orasidagi yo‘l farqlarini to‘g‘ri boshqarish muhimdir.
Misol: O‘zaro platformalar yo‘lini boshqarish
const path = require('path');
// Platform detection
const isWindows = process.platform === 'win32';
const isMac = process.platform === 'darwin';
const isLinux = process.platform === 'linux';
// Platform-specific paths
const appDataDir = isWindows
? path.join(process.env.APPDATA || path.join(process.env.USERPROFILE, 'AppData', 'Roaming'))
: path.join(process.env.HOME || process.env.USERPROFILE, isMac ? 'Library/Application Support' : '.config');
// Application-specific directories
const appName = 'MyApp';
const appDir = path.join(appDataDir, appName);
// Ensure application directory exists
require('fs').mkdirSync(appDir, { recursive: true });
// Platform-specific temporary directory
const tempDir = path.join(require('os').tmpdir(), appName);
// Example: Platform-agnostic path handling
function getConfigPath() {
const configName = 'config.json';
// Development vs production paths
if (process.env.NODE_ENV === 'development') {
return path.join(process.cwd(), 'config', configName);
}
// Production path
return path.join(appDir, configName);
}
console.log('Application directory:', appDir);
console.log('Temporary directory:', tempDir);
console.log('Config file path:', getConfigPath());
Platformalararo maslahatlar:
- Stringlarni birlashtirish o‘rniga har doim
path.join()dan foydalaning - Platformaga xos separator kerak bo‘lganda
path.sepdan foydalaning - Harflar registriga sezgirlikdagi farqlarni hisobga oling (Windows registrga sezgir emas)
- Turli platformalarda yo‘l uzunligi cheklovlaridan xabardor bo‘ling
- Ilovangizni barcha maqsadli platformalarda sinab ko‘ring
Xulosa
Node.js Path moduli fayl yo‘llari bilan izchil va platformadan mustaqil ishlash uchun muhim vositadir.
U quyidagilarga yordam beradigan boy yordamchi dasturlarni taqdim etadi:
- Fayl yo‘llarini tahlil qilish va formatlash
- Yo‘llarni normallashtirish va hal qilish
- Nisbiy va mutlaq yo‘llar bilan ishlash
- Yo‘l komponentlarini manipulyatsiya qilish
- Har qanday operatsion tizimda ishlaydigan o‘zaro faoliyat platforma kodini yozish
Path modulidan foydalanib, siz turli muhitlarda fayl yo‘llarini to‘g‘ri boshqaradigan yanada mustahkam va portativ kod yozishingiz mumkin.
W3Schools Pathfinder
Yutuqlaringizni kuzating – bu bepul!