File System (fs) moduli
Node.js fayl tizimiga kirish
Node.js File System moduli (fs) kompyuteringizdagi fayl tizimi bilan ishlash uchun keng qamrovli metodlar to‘plamini taqdim etadi.
U fayllarni kiritish-chiqarish operatsiyalarini sinxron va asinxron usullarda bajarish imkonini beradi.
Eslatma: Fayl tizimi (fs) moduli asosiy Node.js modulidir, shuning uchun o‘rnatish talab qilinmaydi.
Fayl tizimi (fs) modulini import qilish
Fayl tizimi (fs) modulini CommonJS require() yoki ES modullari import sintaksisi yordamida import qilishingiz mumkin:
CommonJS (Node.js’da standart)
const fs = require('fs');
ES modullari ("turi" bilan Node.js 14+: package.json ichidagi "modul")
import fs from 'fs';
// Or for specific methods:
// import { readFile, writeFile } from 'fs/promises';
Promise-ga asoslangan API
Node.js zamonaviy ilovalar uchun tavsiya etilgan fs/promises nom maydonida File System API ning va’daga asoslangan versiyalarini taqdim etadi:
// Using promises (Node.js 10.0.0+)
const fs = require('fs').promises;
// Or with destructuring
const { readFile, writeFile } = require('fs').promises;
// Or with ES modules
// import { readFile, writeFile } from 'fs/promises';
Umumiy foydalanish holatlari
Fayl operatsiyalari
- Fayllarni o‘qish va yozish
- Fayllarni yaratish va o‘chirish
- Fayllarga qo‘shish
- Fayl nomini o‘zgartirish va ko‘chirish
- Fayl ruxsatlarini o‘zgartiring
Katalog operatsiyalari
- Kataloglarni yaratish va o‘chirish
- Katalog tarkibini ro‘yxatlash
- Fayl o‘zgarishlariga e’tibor bering
- Fayl/katalog statistikasini oling
- Fayl mavjudligini tekshiring
Kengaytirilgan xususiyatlar
- Fayl oqimlari
- Fayl deskriptorlari
- Ramziy havolalar
- Fayl tomosha qilish
- Fayl ruxsatnomalari bilan ishlash
Ishlash bo‘yicha maslahat: Katta hajmdagi fayllar uchun xotirani ko‘p ishlatmaslik uchun oqimlardan ( fs.createReadStream va fs.createWriteStream ) foydalanishni o‘ylab ko‘ring.
Fayllarni o‘qish
Node.js fayllarni o‘qish uchun bir nechta usullarni taqdim etadi, jumladan, callback funksiyasi qilish va Promise-ga asoslangan yondashuvlar.
Eng keng tarqalgan usul - fs.readFile() .
Eslatma: Ilovangiz ishdan chiqishiga yo‘l qo‘ymaslik uchun fayl operatsiyalari bilan ishlashda har doim xatolarni ko‘rib chiqing.
Callback-lar bilan fayllarni o‘qish
An’anaviy callback funksiyasi namunasi yordamida faylni qanday o‘qish mumkin:
myfile.txt
This is the content of myfile.txt
Matn faylini o‘qiydigan Node.js faylini yarating va tarkibni qaytaring:
Misol: Callback-lar bilan faylni o‘qish
const fs = require('fs');
// Read file asynchronously with callback
fs.readFile('myfile.txt', 'utf8', (err, data) => {
if (err) {
console.error('Error reading file:', err);
return;
}
console.log('File content:', data);
});
// For binary data (like images), omit the encoding
fs.readFile('image.png', (err, data) => {
if (err) throw err;
// data is a Buffer containing the file content
console.log('Image size:', data.length, 'bytes');
});
Misolni ishga tushirish »
Fayllarni Promise’lar bilan o‘qish (zamonaviy yondashuv)
Asink/kutish sintaksisini tozalash uchun fs.promises yoki util.promisify dan foydalanish:
Misol: async/await bilan faylni o‘qish
// Using fs.promises (Node.js 10.0.0+)
const fs = require('fs').promises;
async function readFileExample() {
try {
const data = await fs.readFile('myfile.txt', 'utf8');
console.log('File content:', data);
} catch (err) {
console.error('Error reading file:', err);
}
}
readFileExample();
// Or with util.promisify (Node.js 8.0.0+)
const { promisify } = require('util');
const readFileAsync = promisify(require('fs').readFile);
async function readWithPromisify() {
try {
const data = await readFileAsync('myfile.txt', 'utf8');
console.log(data);
} catch (err) {
console.error(err);
}
}
readWithPromisify();
Misolni ishga tushirish »
Fayllarni sinxron o‘qish
Oddiy skriptlar uchun siz sinxron usullardan foydalanishingiz mumkin, ammo ishlab chiqarish serverlarida ulardan qoching, chunki ular voqea siklini bloklaydi:
Misol: Faylni sinxron o‘qish
const fs = require('fs');
try {
// Read file synchronously
const data = fs.readFileSync('myfile.txt', 'utf8');
console.log('File content:', data);
} catch (err) {
console.error('Error reading file:', err);
}
Eng yaxshi amaliyot: Matn fayllarini o‘qiyotganda, Buffer o‘rniga string olish uchun har doim belgilar kodlashni (“utf8” kabi) belgilang.
Fayllarni yaratish va yozish
Node.js fayllarni yaratish va ularga yozish uchun bir necha usullarni taqdim etadi.
Mana eng keng tarqalgan yondashuvlar:
1. fs.writeFile() dan foydalanish
Yangi fayl yaratadi yoki ko‘rsatilgan tarkibga ega mavjud faylning ustiga yozadi:
Misol: faylga yozish
const fs = require('fs').promises;
async function writeFileExample() {
try {
// Write text to a file
await fs.writeFile('myfile.txt', 'Hello, World!', 'utf8');
// Write JSON data
const data = { name: 'John', age: 30, city: 'New York' };
await fs.writeFile('data.json', JSON.stringify(data, null, 2), 'utf8');
console.log('Files created successfully');
} catch (err) {
console.error('Error writing files:', err);
}
}
writeFileExample();
Misolni ishga tushirish »
2. fs.appendFile() dan foydalanish
Faylga kontent qo‘shadi, agar u mavjud bo‘lmasa, uni yaratadi:
Misol: faylga qo‘shish
const fs = require('fs').promises;
async function appendToFile() {
try {
// Append a timestamped log entry
const logEntry = `${new Date().toISOString()}: Application started\n`;
await fs.appendFile('app.log', logEntry, 'utf8');
console.log('Log entry added');
} catch (err) {
console.error('Error appending to file:', err);
}
}
appendToFile();
Misolni ishga tushirish »
3. Fayl tutqichlaridan foydalanish
Fayl operatsiyalari ustidan ko‘proq nazorat qilish uchun siz fayl tutqichlaridan foydalanishingiz mumkin:
Misol: Fayl tutqichlaridan foydalanish
const fs = require('fs').promises;
async function writeWithFileHandle() {
let fileHandle;
try {
// Open a file for writing (creates if doesn't exist)
fileHandle = await fs.open('output.txt', 'w');
// Write content to the file
await fileHandle.write('First line\n');
await fileHandle.write('Second line\n');
await fileHandle.write('Third line\n');
console.log('Content written successfully');
} catch (err) {
console.error('Error writing to file:', err);
} finally {
// Always close the file handle
if (fileHandle) {
await fileHandle.close();
}
}
}
writeWithFileHandle();
Misolni ishga tushirish »
4. Katta fayllar uchun oqimlardan foydalanish
Katta hajmdagi ma’lumotlarni yozish uchun, ko‘p xotiradan foydalanishni oldini olish uchun oqimlardan foydalaning:
Misol: Streamlar bilan katta hajmdagi fayllarni yozish
const fs = require('fs');
const { pipeline } = require('stream/promises');
const { Readable } = require('stream');
async function writeLargeFile() {
// Create a readable stream (could be from HTTP request, etc.)
const data = Array(1000).fill().map((_, i) => `Line ${i + 1}: ${'x'.repeat(100)}\n`);
const readable = Readable.from(data);
// Create a writable stream to a file
const writable = fs.createWriteStream('large-file.txt');
try {
// Pipe the data from readable to writable
await pipeline(readable, writable);
console.log('Large file written successfully');
} catch (err) {
console.error('Error writing file:', err);
}
}
writeLargeFile();
Misolni ishga tushirish »
Fayl bayroqlari: Fayllarni ochishda siz turli rejimlarni belgilashingiz mumkin:
'w'- Yozish uchun ochish (fayl yaratiladi yoki mazmuni tozalanadi)'wx'- "w" kabi, lekin yo‘l mavjud bo‘lsa, bajarilmaydi'w+'- O‘qish va yozish uchun ochish (fayl yaratiladi yoki mazmuni tozalanadi)'a'- Qo‘shish uchun ochiq (fayl mavjud bo‘lmasa yaratiladi)'ax'- "a" kabi, lekin yo‘l mavjud bo‘lsa, muvaffaqiyatsiz bo‘ladi'r+'- O‘qish va yozish uchun ochish (fayl mavjud bo‘lishi shart)
Fayllar va kataloglarni o‘chirish
Node.js fayl va kataloglarni o‘chirishning bir necha usullarini taqdim etadi.
Turli xil o‘chirish stsenariylarini qanday boshqarish mumkin:
1. Bitta faylni o‘chirish
Faylni o‘chirish uchun fs.unlink() dan foydalaning:
Misol: faylni o‘chirish
const fs = require('fs').promises;
async function deleteFile() {
const filePath = 'file-to-delete.txt';
try {
// Check if file exists before deleting
await fs.access(filePath);
// Delete the file
await fs.unlink(filePath);
console.log('File deleted successfully');
} catch (err) {
if (err.code === 'ENOENT') {
console.log('File does not exist');
} else {
console.error('Error deleting file:', err);
}
}
}
deleteFile();
Misolni ishga tushirish »
2. Bir nechta fayllarni o‘chirish
Bir nechta fayllarni o‘chirish uchun Promise.all() dan fs.unlink() bilan foydalanishingiz mumkin:
Misol: bir nechta fayllarni o‘chirish
const fs = require('fs').promises;
const path = require('path');
async function deleteFiles() {
const filesToDelete = [
'temp1.txt',
'temp2.txt',
'temp3.txt'
];
try {
// Delete all files in parallel
await Promise.all(
filesToDelete.map(file =>
fs.unlink(file).catch(err => {
if (err.code !== 'ENOENT') {
console.error(`Error deleting ${file}:`, err);
}
})
)
);
console.log('Files deleted successfully');
} catch (err) {
console.error('Error during file deletion:', err);
}
}
deleteFiles();
Misolni ishga tushirish »
3. Kataloglarni o‘chirish
Kataloglarni o‘chirish uchun ehtiyojlaringizga qarab bir nechta variant mavjud:
Misol: kataloglarni o‘chirish
const fs = require('fs').promises;
const path = require('path');
async function deleteDirectory(dirPath) {
try {
// Check if the directory exists
const stats = await fs.stat(dirPath);
if (!stats.isDirectory()) {
console.log('Path is not a directory');
return;
}
// For Node.js 14.14.0+ (recommended)
await fs.rm(dirPath, { recursive: true, force: true });
// For older Node.js versions (deprecated but still works)
// await fs.rmdir(dirPath, { recursive: true });
console.log('Directory deleted successfully');
} catch (err) {
if (err.code === 'ENOENT') {
console.log('Directory does not exist');
} else {
console.error('Error deleting directory:', err);
}
}
}
// Usage
deleteDirectory('directory-to-delete');
Misolni ishga tushirish »
4. Katalogni o‘chirmasdan bo‘shatish
Katalogdagi barcha fayllar va pastki kataloglarni olib tashlash, lekin katalogning o‘zini saqlash uchun:
Misol: katalogni bo‘shatish
const fs = require('fs').promises;
const path = require('path');
async function emptyDirectory(dirPath) {
try {
// Read the directory
const files = await fs.readdir(dirPath, { withFileTypes: true });
// Delete all files and directories in parallel
await Promise.all(
files.map(file => {
const fullPath = path.join(dirPath, file.name);
return file.isDirectory()
? fs.rm(fullPath, { recursive: true, force: true })
: fs.unlink(fullPath);
})
);
console.log('Directory emptied successfully');
} catch (err) {
console.error('Error emptying directory:', err);
}
}
// Usage
emptyDirectory('directory-to-empty');
Misolni ishga tushirish »
Xavfsizlik bo‘yicha eslatma: Fayllarni o‘chirishda, ayniqsa rekursiv opsiyalardan yoki joker belgilardan foydalanganda juda ehtiyot bo‘ling. Kataloglar bo‘ylab hujumlarning oldini olish uchun har doim fayl yo‘llarini tekshiring va tozalang.
Fayl nomini o‘zgartirish va ko‘chirish
fs.rename() usuli fayllar nomini o‘zgartirish va ko‘chirish uchun ishlatilishi mumkin.
Bu fayl yo‘llarini o‘zgartirishni o‘z ichiga olgan fayl tizimi (fs) operatsiyalari uchun ko‘p qirrali usul.
1. Asosiy fayl nomini o‘zgartirish
Xuddi shu katalogdagi fayl nomini o‘zgartirish uchun:
Misol: fayl nomini o‘zgartirish
const fs = require('fs').promises;
async function renameFile() {
const oldPath = 'old-name.txt';
const newPath = 'new-name.txt';
try {
// Check if source file exists
await fs.access(oldPath);
// Check if destination file already exists
try {
await fs.access(newPath);
console.log('Destination file already exists');
return;
} catch (err) {
// Destination doesn't exist, safe to proceed
}
// Perform the rename
await fs.rename(oldPath, newPath);
console.log('File renamed successfully');
} catch (err) {
if (err.code === 'ENOENT') {
console.log('Source file does not exist');
} else {
console.error('Error renaming file:', err);
}
}
}
// Usage
renameFile();
Misolni ishga tushirish »
2. Fayllarni kataloglar orasiga ko‘chirish
Fayllarni kataloglar o‘rtasida ko‘chirish uchun fs.rename() dan foydalanishingiz mumkin:
Misol: faylni boshqa katalogga ko‘chirish
const fs = require('fs').promises;
const path = require('path');
async function moveFile() {
const sourceFile = 'source/file.txt';
const targetDir = 'destination';
const targetFile = path.join(targetDir, 'file.txt');
try {
// Ensure source file exists
await fs.access(sourceFile);
// Create target directory if it doesn't exist
await fs.mkdir(targetDir, { recursive: true });
// Move the file
await fs.rename(sourceFile, targetFile);
console.log('File moved successfully');
} catch (err) {
if (err.code === 'ENOENT') {
console.log('Source file does not exist');
} else if (err.code === 'EXDEV') {
console.log('Cross-device move detected, using copy+delete fallback');
await moveAcrossDevices(sourceFile, targetFile);
} else {
console.error('Error moving file:', err);
}
}
}
// Helper function for cross-device moves
async function moveAcrossDevices(source, target) {
try {
// Copy the file
await fs.copyFile(source, target);
// Delete the original
await fs.unlink(source);
console.log('File moved across devices successfully');
} catch (err) {
// Clean up if something went wrong
try { await fs.unlink(target); } catch (e) {}
throw err;
}
}
// Usage
moveFile();
Misolni ishga tushirish »
3. Fayllar nomini o‘zgartirish
Shaklga mos keladigan bir nechta fayl nomini o‘zgartirish uchun:
Misol: Fayllar nomini o‘zgartirish
const fs = require('fs').promises;
const path = require('path');
async function batchRename() {
const directory = 'images';
const pattern = /^image(\d+)\.jpg$/;
try {
// Read directory contents
const files = await fs.readdir(directory);
// Process each file
for (const file of files) {
const match = file.match(pattern);
if (match) {
const [_, number] = match;
const newName = `photo-${number.padStart(3, '0')}.jpg`;
const oldPath = path.join(directory, file);
const newPath = path.join(directory, newName);
// Skip if the new name is the same as the old name
if (oldPath !== newPath) {
await fs.rename(oldPath, newPath);
console.log(`Renamed: ${file} - ${newName}`);
}
}
}
console.log('Batch rename completed');
} catch (err) {
console.error('Error during batch rename:', err);
}
}
batchRename();
Misolni ishga tushirish »
4. Atom nomini o‘zgartirish operatsiyalari
Muhim operatsiyalar uchun atomiklikni ta’minlash uchun vaqtinchalik fayldan foydalaning:
Misol: Atom faylini yangilash
const fs = require('fs').promises;
const path = require('path');
const os = require('os');
async function updateFileAtomic(filePath, newContent) {
const tempPath = path.join(
os.tmpdir(),
`temp-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`
);
try {
// 1. Write to temp file
await fs.writeFile(tempPath, newContent, 'utf8');
// 2. Verify the temp file was written correctly
const stats = await fs.stat(tempPath);
if (stats.size === 0) {
throw new Error('Temporary file is empty');
}
// 3. Rename (atomic on most systems)
await fs.rename(tempPath, filePath);
console.log('File updated atomically');
} catch (err) {
// Clean up temp file if it exists
try { await fs.unlink(tempPath); } catch (e) {}
console.error('Atomic update failed:', err);
throw err;
}
}
// Usage
updateFileAtomic('important-config.json', JSON.stringify({ key: 'value' }, null, 2));
Platformalararo Eslatma: fs.rename() operatsiyasi Unix-ga o‘xshash tizimlarda atomik, lekin Windows-da bo‘lmasligi mumkin.
O‘zaro platformali atom operatsiyalari uchun yuqoridagi misolda ko‘rsatilganidek, vaqtinchalik fayl yondashuvidan foydalanishni ko‘rib chiqing.
W3Schools Pathfinder
Yutuqlaringizni kuzating – bu bepul!