TypeScript ফাইল সিস্টেম দক্ষতা: বিশ্বব্যাপী ডেভেলপারদের জন্য টাইপ সেফটি সহ Node.js ফাইল অপারেশন

আধুনিক সফটওয়্যার ডেভেলপমেন্টের বিশাল পরিমণ্ডলে, Node.js স্কেলেবল সার্ভার-সাইড অ্যাপ্লিকেশন, কমান্ড-লাইন টুলস এবং আরও অনেক কিছু তৈরির জন্য একটি শক্তিশালী রানটাইম হিসেবে দাঁড়িয়ে আছে। অনেক Node.js অ্যাপ্লিকেশনের একটি মৌলিক দিক হল ফাইল সিস্টেমের সাথে ইন্টারঅ্যাক্ট করা – ফাইল এবং ডিরেক্টরি পড়া, লেখা, তৈরি করা এবং পরিচালনা করা। যদিও JavaScript এই অপারেশনগুলি পরিচালনা করার জন্য নমনীয়তা প্রদান করে, TypeScript-এর প্রবর্তন স্ট্যাটিক টাইপ-চেকিং, উন্নত টুলিং এবং শেষ পর্যন্ত, আপনার ফাইল সিস্টেম কোডে আরও বেশি নির্ভরযোগ্যতা এবং রক্ষণাবেক্ষণযোগ্যতা এনে এই অভিজ্ঞতাকে উন্নত করে তোলে।

এই বিস্তারিত নির্দেশিকা বিশ্বব্যাপী ডেভেলপারদের জন্য তৈরি করা হয়েছে, তাদের সাংস্কৃতিক পটভূমি বা ভৌগোলিক অবস্থান নির্বিশেষে, যারা TypeScript-এর প্রদানকৃত দৃঢ়তা সহ Node.js ফাইল অপারেশন আয়ত্ত করতে চান। আমরা মূল fs মডিউলে প্রবেশ করব, এর বিভিন্ন সিঙ্ক্রোনাস এবং অ্যাসিঙ্ক্রোনাস দৃষ্টান্ত অন্বেষণ করব, আধুনিক প্রমিস-ভিত্তিক API গুলি পরীক্ষা করব এবং উন্মোচন করব কিভাবে TypeScript-এর টাইপ সিস্টেম সাধারণ ত্রুটিগুলি উল্লেখযোগ্যভাবে হ্রাস করতে এবং আপনার কোডের স্পষ্টতা উন্নত করতে পারে।

মূলভিত্তি: Node.js ফাইল সিস্টেম (fs) বোঝা

Node.js fs মডিউলটি স্ট্যান্ডার্ড POSIX ফাংশনগুলির উপর ভিত্তি করে ফাইল সিস্টেমের সাথে ইন্টারঅ্যাক্ট করার জন্য একটি API সরবরাহ করে। এটি মৌলিক ফাইল পড়া এবং লেখা থেকে শুরু করে জটিল ডিরেক্টরি ম্যানিপুলেশন এবং ফাইল দেখা পর্যন্ত বিস্তৃত পদ্ধতি সরবরাহ করে। ঐতিহ্যগতভাবে, এই অপারেশনগুলি কলব্যাক দিয়ে পরিচালনা করা হত, যার ফলে জটিল পরিস্থিতিতে কুখ্যাত "কলব্যাক হেল" তৈরি হত। Node.js এর বিবর্তনের সাথে, প্রমিস এবং async/await অ্যাসিঙ্ক্রোনাস অপারেশনগুলির জন্য পছন্দের প্যাটার্ন হিসাবে আবির্ভূত হয়েছে, যা কোডকে আরও পঠনযোগ্য এবং পরিচালনাযোগ্য করে তোলে।

ফাইল সিস্টেম অপারেশনগুলির জন্য TypeScript কেন?

যদিও Node.js-এর fs মডিউলটি প্লেইন JavaScript-এর সাথে পুরোপুরি কাজ করে, TypeScript-কে একত্রিত করা বেশ কিছু শক্তিশালী সুবিধা নিয়ে আসে:

• টাইপ সেফটি: ভুল আর্গুমেন্ট টাইপ, অনুপস্থিত প্যারামিটার বা অপ্রত্যাশিত রিটার্ন মানের মতো সাধারণ ত্রুটিগুলি কম্পাইল টাইমে ধরে ফেলে, আপনার কোড রান করার আগেই। এটি অমূল্য, বিশেষ করে যখন বিভিন্ন ফাইল এনকোডিং, ফ্ল্যাগ এবং Buffer অবজেক্ট নিয়ে কাজ করা হয়।
• উন্নত পঠনযোগ্যতা: স্পষ্ট টাইপ অ্যানোটেশনগুলি একটি ফাংশন কী ধরনের ডেটা আশা করে এবং কী রিটার্ন করবে তা পরিষ্কার করে তোলে, যা বিভিন্ন দলের ডেভেলপারদের জন্য কোড বোঝা সহজ করে।
• উন্নত টুলিং ও অটোকম্প্লেশন: IDE গুলি (যেমন VS Code) TypeScript-এর টাইপ সংজ্ঞা ব্যবহার করে বুদ্ধিমান অটোকম্প্লেশন, প্যারামিটার ইঙ্গিত এবং ইনলাইন ডকুমেন্টেশন সরবরাহ করে, যা উৎপাদনশীলতা উল্লেখযোগ্যভাবে বৃদ্ধি করে।
• রিফ্যাক্টরিং আত্মবিশ্বাস: যখন আপনি একটি ইন্টারফেস বা একটি ফাংশন সিগনেচার পরিবর্তন করেন, TypeScript তাৎক্ষণিকভাবে সমস্ত প্রভাবিত ক্ষেত্র চিহ্নিত করে, যা বড় আকারের রিফ্যাক্টরিংকে কম ত্রুটি-প্রবণ করে তোলে।
• বিশ্বব্যাপী ধারাবাহিকতা: আন্তর্জাতিক ডেভেলপমেন্ট দলগুলির মধ্যে একটি সামঞ্জস্যপূর্ণ কোডিং স্টাইল এবং ডেটা কাঠামো সম্পর্কে বোঝাপড়া নিশ্চিত করে, যা অস্পষ্টতা হ্রাস করে।

সিঙ্ক্রোনাস বনাম অ্যাসিঙ্ক্রোনাস অপারেশন: একটি বিশ্বব্যাপী দৃষ্টিকোণ

সিঙ্ক্রোনাস এবং অ্যাসিঙ্ক্রোনাস অপারেশনগুলির মধ্যে পার্থক্য বোঝা অত্যন্ত গুরুত্বপূর্ণ, বিশেষ করে যখন বিশ্বব্যাপী স্থাপনার জন্য অ্যাপ্লিকেশন তৈরি করা হয় যেখানে কার্যকারিতা এবং প্রতিক্রিয়াশীলতা সর্বাগ্রে। বেশিরভাগ fs মডিউল ফাংশন সিঙ্ক্রোনাস এবং অ্যাসিঙ্ক্রোনাস উভয় প্রকারেই আসে। একটি সাধারণ নিয়ম হিসাবে, নন-ব্লকিং I/O অপারেশনগুলির জন্য অ্যাসিঙ্ক্রোনাস পদ্ধতিগুলি পছন্দ করা হয়, যা আপনার Node.js সার্ভারের প্রতিক্রিয়াশীলতা বজায় রাখার জন্য অপরিহার্য।

• অ্যাসিঙ্ক্রোনাস (নন-ব্লকিং): এই পদ্ধতিগুলি তাদের শেষ আর্গুমেন্ট হিসাবে একটি কলব্যাক ফাংশন নেয় বা একটি Promise রিটার্ন করে। তারা ফাইল সিস্টেম অপারেশন শুরু করে এবং অবিলম্বে ফিরে আসে, যা অন্য কোডগুলিকে কার্যকর করার অনুমতি দেয়। যখন অপারেশন সম্পূর্ণ হয়, তখন কলব্যাক আহ্বান করা হয় (বা প্রমিস সমাধান/প্রত্যাখ্যান হয়)। এটি বিশ্বজুড়ে ব্যবহারকারীদের থেকে একাধিক যুগপত অনুরোধ পরিচালনা করে এমন সার্ভার অ্যাপ্লিকেশনগুলির জন্য আদর্শ, কারণ এটি একটি ফাইল অপারেশন শেষ হওয়ার জন্য অপেক্ষা করার সময় সার্ভারকে ফ্রিজ হওয়া থেকে রক্ষা করে।
• সিঙ্ক্রোনাস (ব্লকিং): এই পদ্ধতিগুলি ফিরে আসার আগে অপারেশনটি সম্পূর্ণভাবে সম্পন্ন করে। কোড করা সহজ হলেও, তারা Node.js ইভেন্ট লুপকে ব্লক করে, ফাইল সিস্টেম অপারেশন সম্পন্ন না হওয়া পর্যন্ত অন্য কোনও কোডকে চালানো থেকে বিরত রাখে। এটি উল্লেখযোগ্য কার্যকারিতা বাধা এবং প্রতিক্রিয়াহীন অ্যাপ্লিকেশন তৈরি করতে পারে, বিশেষ করে উচ্চ-ট্র্যাফিক পরিবেশে। এগুলি অল্প ব্যবহার করুন, সাধারণত অ্যাপ্লিকেশন স্টার্টআপ লজিক বা সাধারণ স্ক্রিপ্টগুলির জন্য যেখানে ব্লকিং গ্রহণযোগ্য।

TypeScript-এ মূল ফাইল অপারেশন প্রকার

চলুন, সাধারণ ফাইল সিস্টেম অপারেশনগুলির সাথে TypeScript-এর ব্যবহারিক প্রয়োগে ডুব দেওয়া যাক। আমরা Node.js-এর জন্য বিল্ট-ইন টাইপ সংজ্ঞা ব্যবহার করব, যা সাধারণত @types/node প্যাকেজের মাধ্যমে উপলব্ধ।

শুরু করতে, নিশ্চিত করুন যে আপনার প্রোজেক্টে TypeScript এবং Node.js টাইপগুলি ইনস্টল করা আছে:

npm install typescript @types/node --save-dev

আপনার tsconfig.json সঠিকভাবে কনফিগার করা উচিত, উদাহরণস্বরূপ:

{ "compilerOptions": { "target": "es2020", "module": "commonjs", "outDir": "./dist", "strict": true, "esModuleInterop": true, "skipLibCheck": true, "forceConsistentCasingInFileNames": true }, "include": ["src/**/*"] }

ফাইল পড়া: readFile, readFileSync এবং প্রমিসেস API

ফাইল থেকে বিষয়বস্তু পড়া একটি মৌলিক অপারেশন। TypeScript আপনাকে ফাইল পাথ, এনকোডিং এবং সম্ভাব্য ত্রুটিগুলি সঠিকভাবে পরিচালনা করতে সহায়তা করে।

অ্যাসিঙ্ক্রোনাস ফাইল পড়া (কলব্যাক-ভিত্তিক)

fs.readFile ফাংশনটি অ্যাসিঙ্ক্রোনাস ফাইল পড়ার জন্য প্রধান হাতিয়ার। এটি পাথ, একটি ঐচ্ছিক এনকোডিং এবং একটি কলব্যাক ফাংশন নেয়। TypeScript নিশ্চিত করে যে কলব্যাক-এর আর্গুমেন্টগুলি সঠিকভাবে টাইপ করা হয়েছে (Error | null, Buffer | string)।

import * as fs from 'fs'; const filePath: string = 'data/example.txt'; fs.readFile(filePath, 'utf8', (err: NodeJS.ErrnoException | null, data: string) => { if (err) { // Log error for international debugging, e.g., 'File not found' console.error(`Error reading file '${filePath}': ${err.message}`); return; } // Process file content, ensuring it's a string as per 'utf8' encoding console.log(`File content (${filePath}):\n${data}`); }); // Example: Reading binary data (no encoding specified) const binaryFilePath: string = 'data/image.png'; fs.readFile(binaryFilePath, (err: NodeJS.ErrnoException | null, data: Buffer) => { if (err) { console.error(`Error reading binary file '${binaryFilePath}': ${err.message}`); return; } // 'data' is a Buffer here, ready for further processing (e.g., streaming to a client) console.log(`Read ${data.byteLength} bytes from ${binaryFilePath}`); });

সিঙ্ক্রোনাস ফাইল পড়া

fs.readFileSync ইভেন্ট লুপকে ব্লক করে। এর রিটার্ন টাইপ Buffer বা string হয় একটি এনকোডিং সরবরাহ করা হয়েছে কিনা তার উপর নির্ভর করে। TypeScript এটি সঠিকভাবে অনুমান করে।

import *s fs from 'fs'; const syncFilePath: string = 'data/sync_example.txt'; try { const content: string = fs.readFileSync(syncFilePath, 'utf8'); console.log(`Synchronous read content (${syncFilePath}):\n${content}`); } catch (error: any) { console.error(`Synchronous read error for '${syncFilePath}': ${error.message}`); }

প্রমিস-ভিত্তিক ফাইল পড়া (fs/promises)

আধুনিক fs/promises API একটি পরিষ্কার, প্রমিস-ভিত্তিক ইন্টারফেস অফার করে, যা অ্যাসিঙ্ক্রোনাস অপারেশনগুলির জন্য অত্যন্ত সুপারিশ করা হয়। TypeScript এখানে বিশেষভাবে async/await এর সাথে চমৎকার কাজ করে।

import * as fsPromises from 'fs/promises'; async function readTextFile(path: string): Promise { try { // fsPromises.readFile infers return type as string if 'utf8' is given const content: string = await fsPromises.readFile(path, { encoding: 'utf8' }); console.log(`Promise-based read content (${path}):\n${content}`); } catch (error: any) { console.error(`Promise-based read error for '${path}': ${error.message}`); } } async function readBinaryFile(path: string): Promise { try { // fsPromises.readFile infers return type as Buffer if no encoding is given const buffer: Buffer = await fsPromises.readFile(path); console.log(`Promise-based read binary content (${path}): ${buffer.byteLength} bytes`); } catch (error: any) { console.error(`Promise-based read binary error for '${path}': ${error.message}`); } } // Create dummy files for demonstration (optional, for local testing) async function setupFiles() { await fsPromises.mkdir('data', { recursive: true }); await fsPromises.writeFile('data/example.txt', 'Hello from TypeScript FS!'); await fsPromises.writeFile('data/sync_example.txt', 'Synchronous content.'); // For binary, we just create a small buffer await fsPromises.writeFile('data/image.png', Buffer.from([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A])); } setupFiles().then(() => { readTextFile('data/example.txt'); readTextFile('non_existent_file.txt'); // Demonstrates error handling readBinaryFile('data/image.png'); }).catch(err => console.error('Setup error:', err));

ফাইল লেখা: writeFile, writeFileSync এবং ফ্ল্যাগ

ফাইলগুলিতে ডেটা লেখা একইভাবে গুরুত্বপূর্ণ। TypeScript ফাইল পাথ, ডেটা টাইপ (স্ট্রিং বা বাফার), এনকোডিং এবং ফাইল ওপেন ফ্ল্যাগ পরিচালনা করতে সহায়তা করে।

অ্যাসিঙ্ক্রোনাস ফাইল লেখা

fs.writeFile একটি ফাইলে ডেটা লেখার জন্য ব্যবহৃত হয়, যা ফাইলটি ইতিমধ্যে বিদ্যমান থাকলে ডিফল্টরূপে প্রতিস্থাপন করে। আপনি flags দিয়ে এই আচরণ নিয়ন্ত্রণ করতে পারেন।

import * as fs from 'fs'; const outputFilePath: string = 'data/output.txt'; const fileContent: string = 'This is new content written by TypeScript.'; fs.writeFile(outputFilePath, fileContent, 'utf8', (err: NodeJS.ErrnoException | null) => { if (err) { console.error(`Error writing file '${outputFilePath}': ${err.message}`); return; } console.log(`File '${outputFilePath}' written successfully.`); }); // Example with Buffer data const bufferContent: Buffer = Buffer.from('Binary data example'); const binaryOutputFilePath: string = 'data/binary_output.bin'; fs.writeFile(binaryOutputFilePath, bufferContent, (err: NodeJS.ErrnoException | null) => { if (err) { console.error(`Error writing binary file '${binaryOutputFilePath}': ${err.message}`); return; } console.log(`Binary file '${binaryOutputFilePath}' written successfully.`); });

সিঙ্ক্রোনাস ফাইল লেখা

fs.writeFileSync লেখা অপারেশন সম্পন্ন না হওয়া পর্যন্ত ইভেন্ট লুপকে ব্লক করে।

import * as fs from 'fs'; const syncOutputFilePath: string = 'data/sync_output.txt'; try { fs.writeFileSync(syncOutputFilePath, 'Synchronously written content.', 'utf8'); console.log(`File '${syncOutputFilePath}' written synchronously.`); } catch (error: any) { console.error(`Synchronous write error for '${syncOutputFilePath}': ${error.message}`); }

প্রমিস-ভিত্তিক ফাইল লেখা (fs/promises)

async/await এবং fs/promises সহ আধুনিক পদ্ধতিটি প্রায়শই অ্যাসিঙ্ক্রোনাস লেখাগুলি পরিচালনা করার জন্য আরও পরিষ্কার।

import * as fsPromises from 'fs/promises'; import { constants as fsConstants } from 'fs'; // For flags async function writeDataToFile(path: string, data: string | Buffer): Promise { try { await fsPromises.writeFile(path, data, { encoding: 'utf8' }); console.log(`File '${path}' written successfully using promises.`); } catch (error: any) { console.error(`Error writing file '${path}' with promises: ${error.message}`); } } // Demonstrating overwrite vs. append using flags async function writeWithFlags(path: string, data: string, flag: string | number): Promise { try { await fsPromises.writeFile(path, data, { flag: flag, encoding: 'utf8' }); console.log(`File '${path}' written with flag '${flag}' successfully.`); } catch (error: any) { console.error(`Error writing file '${path}' with flag '${flag}': ${error.message}`); } } (async () => { // Initial write (creates or overwrites) await writeDataToFile('data/flags_example.txt', 'First line.\n'); // Append to existing file await writeWithFlags('data/flags_example.txt', 'Second line (appended).\n', 'a'); // Write only if file does not exist (exclusive write) await writeWithFlags('data/new_exclusive.txt', 'Exclusive content.\n', 'wx'); // This would fail if 'data/new_exclusive.txt' already exists from a previous run await writeWithFlags('data/new_exclusive.txt', 'Attempt to overwrite exclusive content (should fail if file exists).\n', 'wx'); })();

গুরুত্বপূর্ণ ফ্ল্যাগসমূহ:

• 'w' (ডিফল্ট): লেখার জন্য ফাইল খুলুন। ফাইলটি তৈরি করা হয় (যদি এটি বিদ্যমান না থাকে) বা ট্রাঙ্কেট করা হয় (যদি এটি বিদ্যমান থাকে)।
• 'w+': পড়া এবং লেখার জন্য ফাইল খুলুন। ফাইলটি তৈরি করা হয় (যদি এটি বিদ্যমান না থাকে) বা ট্রাঙ্কেট করা হয় (যদি এটি বিদ্যমান থাকে)।
• 'a' (সংযোজন): সংযোজন করার জন্য ফাইল খুলুন। ফাইলটি তৈরি করা হয় যদি এটি বিদ্যমান না থাকে।
• 'a+': পড়া এবং সংযোজন করার জন্য ফাইল খুলুন। ফাইলটি তৈরি করা হয় যদি এটি বিদ্যমান না থাকে।
• 'r' (পড়া): পড়ার জন্য ফাইল খুলুন। ফাইলটি বিদ্যমান না থাকলে একটি ব্যতিক্রম ঘটে।
• 'r+': পড়া এবং লেখার জন্য ফাইল খুলুন। ফাইলটি বিদ্যমান না থাকলে একটি ব্যতিক্রম ঘটে।
• 'wx' (একচেটিয়া লেখা): 'w' এর মতো কিন্তু যদি পাথ বিদ্যমান থাকে তবে ব্যর্থ হয়।
• 'ax' (একচেটিয়া সংযোজন): 'a' এর মতো কিন্তু যদি পাথ বিদ্যমান থাকে তবে ব্যর্থ হয়।

ফাইলগুলিতে সংযোজন: appendFile, appendFileSync

যখন আপনাকে একটি বিদ্যমান ফাইলের শেষে তার বিষয়বস্তু ওভাররাইট না করে ডেটা যোগ করতে হবে, তখন appendFile আপনার পছন্দ। এটি লগিং, ডেটা সংগ্রহ বা অডিট ট্রেইলগুলির জন্য বিশেষভাবে উপযোগী।

অ্যাসিঙ্ক্রোনাস সংযোজন

import * as fs from 'fs'; const logFilePath: string = 'data/app_logs.log'; function logMessage(message: string): void { const timestamp: string = new Date().toISOString(); const logEntry: string = `${timestamp} - ${message}\n`; fs.appendFile(logFilePath, logEntry, 'utf8', (err: NodeJS.ErrnoException | null) => { if (err) { console.error(`Error appending to log file '${logFilePath}': ${err.message}`); return; } console.log(`Logged message to '${logFilePath}'.`); }); } logMessage('User "Alice" logged in.'); setTimeout(() => logMessage('System update initiated.'), 50); logMessage('Database connection established.');

সিঙ্ক্রোনাস সংযোজন

import * as fs from 'fs'; const syncLogFilePath: string = 'data/sync_app_logs.log'; function logMessageSync(message: string): void { const timestamp: string = new Date().toISOString(); const logEntry: string = `${timestamp} - ${message}\n`; try { fs.appendFileSync(syncLogFilePath, logEntry, 'utf8'); console.log(`Logged message synchronously to '${syncLogFilePath}'.`); } catch (error: any) { console.error(`Synchronous error appending to log file '${syncLogFilePath}': ${error.message}`); } } logMessageSync('Application started.'); logMessageSync('Configuration loaded.');

প্রমিস-ভিত্তিক সংযোজন (fs/promises)

import * as fsPromises from 'fs/promises'; const promiseLogFilePath: string = 'data/promise_app_logs.log'; async function logMessagePromise(message: string): Promise { const timestamp: string = new Date().toISOString(); const logEntry: string = `${timestamp} - ${message}\n`; try { await fsPromises.appendFile(promiseLogFilePath, logEntry, 'utf8'); console.log(`Logged message using promises to '${promiseLogFilePath}'.`); } catch (error: any) { console.error(`Error appending to log file '${promiseLogFilePath}' with promises: ${error.message}`); } } (async () => { await logMessagePromise('Service initialized.'); await logMessagePromise('Data processing started.'); })();

ফাইল মুছে ফেলা: unlink, unlinkSync

ফাইল সিস্টেম থেকে ফাইল মুছে ফেলা। TypeScript আপনাকে একটি বৈধ পাথ পাস করতে এবং ত্রুটিগুলি সঠিকভাবে পরিচালনা করতে সহায়তা করে।

অ্যাসিঙ্ক্রোনাস মোছা

import * as fs from 'fs'; const fileToDeletePath: string = 'data/temp_to_delete.txt'; // First, create the file to ensure it exists for deletion demo fs.writeFile(fileToDeletePath, 'Temporary content.', 'utf8', (err) => { if (err) { console.error('Error creating file for deletion demo:', err); return; } console.log(`File '${fileToDeletePath}' created for deletion demo.`); fs.unlink(fileToDeletePath, (err: NodeJS.ErrnoException | null) => { if (err) { console.error(`Error deleting file '${fileToDeletePath}': ${err.message}`); return; } console.log(`File '${fileToDeletePath}' deleted successfully.`); }); });

সিঙ্ক্রোনাস মোছা

import * as fs from 'fs'; const syncFileToDeletePath: string = 'data/sync_temp_to_delete.txt'; try { fs.writeFileSync(syncFileToDeletePath, 'Sync temp content.', 'utf8'); console.log(`File '${syncFileToDeletePath}' created.`); fs.unlinkSync(syncFileToDeletePath); console.log(`File '${syncFileToDeletePath}' deleted synchronously.`); } catch (error: any) { console.error(`Synchronous deletion error for '${syncFileToDeletePath}': ${error.message}`); }

প্রমিস-ভিত্তিক মোছা (fs/promises)

import * as fsPromises from 'fs/promises'; const promiseFileToDeletePath: string = 'data/promise_temp_to_delete.txt'; async function deleteFile(path: string): Promise { try { // Create the file first for demonstration purposes await fsPromises.writeFile(path, 'Promise temp content.', 'utf8'); console.log(`File '${path}' created for promise deletion demo.`); await fsPromises.unlink(path); console.log(`File '${path}' deleted successfully using promises.`); } catch (error: any) { console.error(`Error deleting file '${path}' with promises: ${error.message}`); } } deleteFile(promiseFileToDeletePath);

ফাইল অস্তিত্ব এবং অনুমতি পরীক্ষা করা: existsSync, access, accessSync

একটি ফাইলে কাজ করার আগে, আপনাকে এটি বিদ্যমান আছে কিনা বা বর্তমান প্রক্রিয়াটির প্রয়োজনীয় অনুমতি আছে কিনা তা পরীক্ষা করতে হতে পারে। TypeScript mode প্যারামিটারের জন্য টাইপ সরবরাহ করে সহায়তা করে।

সিঙ্ক্রোনাস অস্তিত্ব পরীক্ষা

fs.existsSync একটি সহজ, সিঙ্ক্রোনাস চেক। সুবিধাজনক হলেও, এটির একটি রেস কন্ডিশন দুর্বলতা রয়েছে (existsSync এবং পরবর্তী অপারেশনের মধ্যে একটি ফাইল মুছে ফেলা হতে পারে), তাই গুরুত্বপূর্ণ অপারেশনগুলির জন্য fs.access ব্যবহার করা প্রায়শই ভাল।

import * as fs from 'fs'; const checkFilePath: string = 'data/example.txt'; if (fs.existsSync(checkFilePath)) { console.log(`File '${checkFilePath}' exists.`); } else { console.log(`File '${checkFilePath}' does not exist.`); }

অ্যাসিঙ্ক্রোনাস অনুমতি পরীক্ষা (fs.access)

fs.access path দ্বারা নির্দিষ্ট ফাইল বা ডিরেক্টরির জন্য ব্যবহারকারীর অনুমতি পরীক্ষা করে। এটি অ্যাসিঙ্ক্রোনাস এবং একটি mode আর্গুমেন্ট নেয় (যেমন, অস্তিত্বের জন্য fs.constants.F_OK, পড়ার জন্য R_OK, লেখার জন্য W_OK, এক্সিকিউটের জন্য X_OK)।

import * as fs from 'fs'; import { constants } from 'fs'; const accessFilePath: string = 'data/example.txt'; fs.access(accessFilePath, constants.F_OK, (err: NodeJS.ErrnoException | null) => { if (err) { console.error(`File '${accessFilePath}' does not exist or access denied.`); return; } console.log(`File '${accessFilePath}' exists.`); }); fs.access(accessFilePath, constants.R_OK | constants.W_OK, (err: NodeJS.ErrnoException | null) => { if (err) { console.error(`File '${accessFilePath}' is not readable/writable or access denied: ${err.message}`); return; } console.log(`File '${accessFilePath}' is readable and writable.`); });

প্রমিস-ভিত্তিক অনুমতি পরীক্ষা (fs/promises)

import * as fsPromises from 'fs/promises'; import { constants } from 'fs'; async function checkFilePermissions(path: string, mode: number): Promise { try { await fsPromises.access(path, mode); const modeDescription = (mode === constants.F_OK ? 'exists' : '') + ((mode & constants.R_OK) ? ' readable' : '') + ((mode & constants.W_OK) ? ' writable' : '') + ((mode & constants.X_OK) ? ' executable' : ''); console.log(`File '${path}' is ${modeDescription.trim()}.`); } catch (error: any) { console.error(`File '${path}' access error: ${error.message}`); } } (async () => { await checkFilePermissions('data/example.txt', constants.F_OK); // Check existence await checkFilePermissions('data/example.txt', constants.R_OK | constants.W_OK); // Check read/write await checkFilePermissions('data/non_existent_file.txt', constants.F_OK); // Should error })();

ফাইল তথ্য প্রাপ্তি: stat, statSync, fs.Stats

fs.stat ফাংশনগুলির পরিবার একটি ফাইল বা ডিরেক্টরি সম্পর্কে বিস্তারিত তথ্য সরবরাহ করে, যেমন আকার, তৈরির তারিখ, পরিবর্তনের তারিখ এবং অনুমতি। TypeScript-এর fs.Stats ইন্টারফেস এই ডেটার সাথে কাজ করাকে অত্যন্ত কাঠামোগত এবং নির্ভরযোগ্য করে তোলে।

অ্যাসিঙ্ক্রোনাস স্ট্যাট

import * as fs from 'fs'; import { Stats } from 'fs'; const statFilePath: string = 'data/example.txt'; fs.stat(statFilePath, (err: NodeJS.ErrnoException | null, stats: Stats) => { if (err) { console.error(`Error getting stats for '${statFilePath}': ${err.message}`); return; } console.log(`Stats for '${statFilePath}':`); console.log(` Is file: ${stats.isFile()}`); console.log(` Is directory: ${stats.isDirectory()}`); console.log(` Size: ${stats.size} bytes`); console.log(` Creation time: ${stats.birthtime.toISOString()}`); console.log(` Last modified: ${stats.mtime.toISOString()}`); });

প্রমিস-ভিত্তিক স্ট্যাট (fs/promises)

import * as fsPromises from 'fs/promises'; import { Stats } from 'fs'; // Still use the 'fs' module's Stats interface async function getFileStats(path: string): Promise { try { const stats: Stats = await fsPromises.stat(path); console.log(`Promise-based Stats for '${path}':`); console.log(` Is file: ${stats.isFile()}`); console.log(` Is directory: ${stats.isDirectory()}`); console.log(` Size: ${stats.size} bytes`); console.log(` Creation time: ${stats.birthtime.toISOString()}`); console.log(` Last modified: ${stats.mtime.toISOString()}`); } catch (error: any) { console.error(`Error getting stats for '${path}' with promises: ${error.message}`); } } getFileStats('data/example.txt'); getFileStats('data/non_existent_dir_or_file'); // Should error

TypeScript সহ ডিরেক্টরি অপারেশন

ডিরেক্টরি পরিচালনা করা ফাইল সংগঠিত করা, অ্যাপ্লিকেশন-নির্দিষ্ট স্টোরেজ তৈরি করা বা অস্থায়ী ডেটা পরিচালনার জন্য একটি সাধারণ প্রয়োজন। TypeScript এই অপারেশনগুলির জন্য শক্তিশালী টাইপিং সরবরাহ করে।

ডিরেক্টরি তৈরি করা: mkdir, mkdirSync

fs.mkdir ফাংশনটি নতুন ডিরেক্টরি তৈরি করতে ব্যবহৃত হয়। recursive অপশনটি প্যারেন্ট ডিরেক্টরিগুলি না থাকলে তৈরি করার জন্য অবিশ্বাস্যভাবে কার্যকর, যা Unix-সদৃশ সিস্টেমগুলিতে mkdir -p এর আচরণ অনুকরণ করে।

অ্যাসিঙ্ক্রোনাস ডিরেক্টরি তৈরি

import * as fs from 'fs'; const newDirPath: string = 'data/new_directory'; const recursiveDirPath: string = 'data/nested/path/to/create'; // Create a single directory fs.mkdir(newDirPath, (err: NodeJS.ErrnoException | null) => { if (err) { // Ignore EEXIST error if directory already exists if (err.code === 'EEXIST') { console.log(`Directory '${newDirPath}' already exists.`); } else { console.error(`Error creating directory '${newDirPath}': ${err.message}`); } return; } console.log(`Directory '${newDirPath}' created successfully.`); }); // Create nested directories recursively fs.mkdir(recursiveDirPath, { recursive: true }, (err: NodeJS.ErrnoException | null) => { if (err) { if (err.code === 'EEXIST') { console.log(`Directory '${recursiveDirPath}' already exists.`); } else { console.error(`Error creating recursive directory '${recursiveDirPath}': ${err.message}`); } return; } console.log(`Recursive directories '${recursiveDirPath}' created successfully.`); });

প্রমিস-ভিত্তিক ডিরেক্টরি তৈরি (fs/promises)

import * as fsPromises from 'fs/promises'; async function createDirectory(path: string, recursive: boolean = false): Promise { try { await fsPromises.mkdir(path, { recursive: recursive }); console.log(`Directory '${path}' created successfully (recursive: ${recursive}).`); } catch (error: any) { // Node.js will throw 'EEXIST' error if recursive is false and directory exists if (error.code === 'EEXIST' && !recursive) { console.log(`Directory '${path}' already exists.`); } else if (error.code === 'EEXIST' && recursive) { // With recursive: true, EEXIST is not an error, it just means it exists console.log(`Recursive path '${path}' already exists.`); } else { console.error(`Error creating directory '${path}' with promises: ${error.message}`); } } } (async () => { await createDirectory('data/promise_dir'); await createDirectory('data/promise_dir'); // Demonstrate EEXIST handling await createDirectory('data/promise_nested/path', true); })();

ডিরেক্টরি বিষয়বস্তু পড়া: readdir, readdirSync, fs.Dirent

একটি প্রদত্ত ডিরেক্টরির মধ্যে ফাইল এবং সাবডিরেক্টরিগুলি তালিকাভুক্ত করতে, আপনি fs.readdir ব্যবহার করেন। withFileTypes অপশনটি একটি আধুনিক সংযোজন যা fs.Dirent অবজেক্টগুলি রিটার্ন করে, প্রতিটি এন্ট্রিকে আলাদাভাবে stat করার প্রয়োজন ছাড়াই সরাসরি আরও বিস্তারিত তথ্য সরবরাহ করে।

অ্যাসিঙ্ক্রোনাস ডিরেক্টরি পড়া

import * as fs from 'fs'; const readDirPath: string = 'data'; fs.readdir(readDirPath, (err: NodeJS.ErrnoException | null, files: string[]) => { if (err) { console.error(`Error reading directory '${readDirPath}': ${err.message}`); return; } console.log(`Contents of directory '${readDirPath}':`); files.forEach(file => { console.log(` - ${file}`); }); }); // With `withFileTypes` option fs.readdir(readDirPath, { withFileTypes: true }, (err: NodeJS.ErrnoException | null, dirents: fs.Dirent[]) => { if (err) { console.error(`Error reading directory with file types '${readDirPath}': ${err.message}`); return; } console.log(`Contents of directory '${readDirPath}' (with types):`); dirents.forEach(dirent => { const type: string = dirent.isFile() ? 'File' : dirent.isDirectory() ? 'Directory' : 'Other'; console.log(` - ${dirent.name} (${type})`); }); });

প্রমিস-ভিত্তিক ডিরেক্টরি পড়া (fs/promises)

import * as fsPromises from 'fs/promises'; import { Dirent } from 'fs'; // Still use 'fs' module's Dirent interface async function listDirectoryContents(path: string): Promise { try { const files: string[] = await fsPromises.readdir(path); console.log(`Promise-based contents of directory '${path}':`); files.forEach(file => console.log(` - ${file}`)); } catch (error: any) { console.error(`Error listing directory '${path}' with promises: ${error.message}`); } } async function listDirectoryContentsWithTypes(path: string): Promise { try { const dirents: Dirent[] = await fsPromises.readdir(path, { withFileTypes: true }); console.log(`Promise-based contents of directory '${path}' (with types):`); dirents.forEach(dirent => { const type: string = dirent.isFile() ? 'File' : dirent.isDirectory() ? 'Directory' : 'Other'; console.log(` - ${dirent.name} (${type})`); }); } catch (error: any) { console.error(`Error listing directory '${path}' with types (promises): ${error.message}`); } } (async () => { // Ensure the 'data' directory and some files exist for the demo await fsPromises.mkdir('data', { recursive: true }); await fsPromises.writeFile('data/temp_file1.txt', 'Content 1'); await fsPromises.mkdir('data/sub_dir'); await fsPromises.writeFile('data/sub_dir/temp_file2.txt', 'Content 2'); await listDirectoryContents('data'); await listDirectoryContentsWithTypes('data'); await listDirectoryContents('non_existent_dir'); // Should error })();

ডিরেক্টরি মোছা: rmdir (অননুমোদিত), rm, rmSync

Node.js তার ডিরেক্টরি মোছার পদ্ধতিগুলি উন্নত করেছে। fs.rmdir এখন রিকার্সিভ মোছার জন্য fs.rm দ্বারা মূলত প্রতিস্থাপিত হয়েছে, যা আরও শক্তিশালী এবং সামঞ্জস্যপূর্ণ API অফার করে।

অ্যাসিঙ্ক্রোনাস ডিরেক্টরি মোছা (fs.rm)

fs.rm ফাংশনটি (Node.js 14.14.0 থেকে উপলব্ধ) ফাইল এবং ডিরেক্টরি মুছে ফেলার জন্য প্রস্তাবিত উপায়। অ-খালি ডিরেক্টরিগুলি মুছে ফেলার জন্য recursive: true অপশনটি অত্যন্ত গুরুত্বপূর্ণ।

import * as fs from 'fs'; const dirToDeletePath: string = 'data/dir_to_delete'; const nestedDirToDeletePath: string = 'data/nested_dir/sub'; // Setup: Create a directory with a file inside for recursive deletion demo fs.mkdir(nestedDirToDeletePath, { recursive: true }, (err) => { if (err && err.code !== 'EEXIST') { console.error('Error creating nested directory for demo:', err); return; } fs.writeFile(`${nestedDirToDeletePath}/file_inside.txt`, 'Some content', (err) => { if (err) { console.error('Error creating file inside nested directory:', err); return; } console.log(`Directory '${nestedDirToDeletePath}' and file created for deletion demo.`); fs.rm(nestedDirToDeletePath, { recursive: true, force: true }, (err: NodeJS.ErrnoException | null) => { if (err) { console.error(`Error deleting recursive directory '${nestedDirToDeletePath}': ${err.message}`); return; } console.log(`Recursive directory '${nestedDirToDeletePath}' deleted successfully.`); }); }); }); // Deleting an empty directory fs.mkdir(dirToDeletePath, (err) => { if (err && err.code !== 'EEXIST') { console.error('Error creating empty directory for demo:', err); return; } console.log(`Directory '${dirToDeletePath}' created for deletion demo.`); fs.rm(dirToDeletePath, { recursive: false }, (err: NodeJS.ErrnoException | null) => { if (err) { console.error(`Error deleting empty directory '${dirToDeletePath}': ${err.message}`); return; } console.log(`Empty directory '${dirToDeletePath}' deleted successfully.`); }); });

প্রমিস-ভিত্তিক ডিরেক্টরি মোছা (fs/promises)

import * as fsPromises from 'fs/promises'; async function deleteDirectory(path: string, recursive: boolean = false): Promise { try { // Create a dummy nested structure for recursive deletion testing if (recursive) { await fsPromises.mkdir(`${path}/sub_dir`, { recursive: true }); await fsPromises.writeFile(`${path}/sub_dir/file.txt`, 'test'); } else { await fsPromises.mkdir(path, { recursive: true }); // Ensure parent exists } console.log(`Directory setup at '${path}' for deletion.`); await fsPromises.rm(path, { recursive: recursive, force: true }); console.log(`Directory '${path}' deleted successfully (recursive: ${recursive}).`); } catch (error: any) { console.error(`Error deleting directory '${path}' with promises: ${error.message}`); } } (async () => { await deleteDirectory('data/promise_dir_to_delete', false); // Delete empty await deleteDirectory('data/promise_nested_dir_to_delete', true); // Delete non-empty await deleteDirectory('data/non_existent_dir_to_delete'); // Should handle gracefully })();

TypeScript সহ উন্নত ফাইল সিস্টেম ধারণা

মৌলিক পড়া/লেখা অপারেশনগুলি ছাড়াও, Node.js বৃহত্তর ফাইল, অবিচ্ছিন্ন ডেটা প্রবাহ এবং ফাইল সিস্টেমের রিয়েল-টাইম পর্যবেক্ষণের জন্য শক্তিশালী বৈশিষ্ট্য সরবরাহ করে। TypeScript-এর টাইপ ডিক্লারেশনগুলি এই উন্নত পরিস্থিতিগুলিতে সুন্দরভাবে প্রসারিত হয়, যা দৃঢ়তা নিশ্চিত করে।

ফাইল ডিস্ক্রিপ্টর এবং স্ট্রিমস

খুব বড় ফাইলগুলির জন্য অথবা যখন আপনার ফাইল অ্যাক্সেসের উপর সূক্ষ্ম-দানাযুক্ত নিয়ন্ত্রণের প্রয়োজন হয় (যেমন, একটি ফাইলের মধ্যে নির্দিষ্ট অবস্থান), তখন ফাইল ডিস্ক্রিপ্টর এবং স্ট্রিম অপরিহার্য হয়ে ওঠে। স্ট্রিমগুলি প্রচুর পরিমাণে ডেটা খণ্ডে খণ্ডে পড়া বা লেখার জন্য একটি কার্যকর উপায় সরবরাহ করে, সম্পূর্ণ ফাইল মেমোরিতে লোড করার পরিবর্তে, যা স্কেলেবল অ্যাপ্লিকেশন এবং বিশ্বব্যাপী সার্ভারগুলিতে দক্ষ রিসোর্স ব্যবস্থাপনার জন্য অত্যন্ত গুরুত্বপূর্ণ।

ডিস্ক্রিপ্টর সহ ফাইল খোলা এবং বন্ধ করা (fs.open, fs.close)

একটি ফাইল ডিস্ক্রিপ্টর হল একটি খোলা ফাইলের জন্য অপারেটিং সিস্টেম দ্বারা নির্ধারিত একটি অনন্য শনাক্তকারী (একটি সংখ্যা)। আপনি fs.open ব্যবহার করে একটি ফাইল ডিস্ক্রিপ্টর পেতে পারেন, তারপর সেই ডিস্ক্রিপ্টর ব্যবহার করে fs.read বা fs.write এর মতো অপারেশনগুলি সম্পাদন করতে পারেন এবং অবশেষে এটি fs.close করতে পারেন।

import * as fs from 'fs'; import { promises as fsPromises } from 'fs'; import { constants } from 'fs'; const descriptorFilePath: string = 'data/descriptor_example.txt'; async function demonstrateFileDescriptorOperations(): Promise { let fileDescriptor: number | undefined; try { // Ensure file exists for reading, or create it for writing await fsPromises.writeFile(descriptorFilePath, 'Content to read and modify via descriptor.'); console.log(`File '${descriptorFilePath}' prepared for descriptor demo.`); // Open the file for reading and writing ('r+' flag) // fsPromises.open returns a FileHandle object, which has its own descriptor const fileHandle = await fsPromises.open(descriptorFilePath, constants.O_RDWR); // O_RDWR is for read and write fileDescriptor = fileHandle.fd; // Get the raw file descriptor console.log(`File opened with descriptor: ${fileDescriptor}`); // Read data from the file const buffer = Buffer.alloc(100); const { bytesRead, buffer: readBuffer } = await fileHandle.read(buffer, 0, buffer.length, 0); console.log(`Read ${bytesRead} bytes from descriptor: '${readBuffer.toString('utf8', 0, bytesRead)}'`); // Write data to a specific position (e.g., overwrite 'Content' with 'UPDATED') const writeData = Buffer.from('UPDATED'); const { bytesWritten } = await fileHandle.write(writeData, 0, writeData.length, 0); console.log(`Wrote ${bytesWritten} bytes to descriptor.`); // Read again to confirm changes const bufferAfterWrite = Buffer.alloc(100); const { bytesRead: br2, buffer: readBuffer2 } = await fileHandle.read(bufferAfterWrite, 0, bufferAfterWrite.length, 0); console.log(`Content after write: '${readBuffer2.toString('utf8', 0, br2)}'`); await fileHandle.close(); console.log('File descriptor closed.'); } catch (error: any) { console.error(`Error with file descriptor operations: ${error.message}`); } finally { if (fileDescriptor !== undefined) { // This 'finally' block handles cases where an error might occur *after* fileHandle.open // but *before* fileHandle.close is called, ensuring cleanup. // In this specific async/await structure, fileHandle.close() within try is usually sufficient // unless fileHandle itself fails before .close() can be called. } } } demonstrateFileDescriptorOperations();

ফাইল স্ট্রিমস (fs.createReadStream, fs.createWriteStream)

স্ট্রিমগুলি দক্ষতার সাথে বড় ফাইলগুলি পরিচালনা করার জন্য শক্তিশালী। fs.createReadStream এবং fs.createWriteStream যথাক্রমে Readable এবং Writable স্ট্রিমগুলি রিটার্ন করে, যা Node.js এর স্ট্রিমিং API এর সাথে নির্বিঘ্নে একত্রিত হয়। TypeScript এই স্ট্রিম ইভেন্টগুলির জন্য চমৎকার টাইপ সংজ্ঞা সরবরাহ করে (যেমন, 'data', 'end', 'error')।

import * as fs from 'fs'; const largeFilePath: string = 'data/large_file.txt'; const copiedFilePath: string = 'data/copied_file.txt'; // Create a dummy large file for demonstration function createLargeFile(path: string, sizeInMB: number): void { const content: string = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. '; // 56 chars const stream = fs.createWriteStream(path); const totalChars = sizeInMB * 1024 * 1024; // Convert MB to bytes const iterations = Math.ceil(totalChars / content.length); for (let i = 0; i < iterations; i++) { stream.write(content); } stream.end(() => console.log(`Created large file '${path}' (${sizeInMB}MB).`)); } // For demonstration, let's ensure the 'data' directory exists first fs.mkdir('data', { recursive: true }, (err) => { if (err && err.code !== 'EEXIST') { console.error('Error creating data directory:', err); return; } createLargeFile(largeFilePath, 1); // Create a 1MB file }); // Copy file using streams function copyFileWithStreams(source: string, destination: string): void { const readStream = fs.createReadStream(source); const writeStream = fs.createWriteStream(destination); readStream.on('open', () => console.log(`Reading stream for '${source}' opened.`)); writeStream.on('open', () => console.log(`Writing stream for '${destination}' opened.`)); // Pipe data from read stream to write stream readStream.pipe(writeStream); readStream.on('error', (err: Error) => { console.error(`Read stream error: ${err.message}`); }); writeStream.on('error', (err: Error) => { console.error(`Write stream error: ${err.message}`); }); writeStream.on('finish', () => { console.log(`File '${source}' copied to '${destination}' successfully using streams.`); // Clean up dummy large file after copy fs.unlink(largeFilePath, (err) => { if (err) console.error('Error deleting large file:', err); else console.log(`Large file '${largeFilePath}' deleted.`); }); }); } // Wait a bit for the large file to be created before attempting to copy setTimeout(() => { copyFileWithStreams(largeFilePath, copiedFilePath); }, 1000);

পরিবর্তনগুলি পর্যবেক্ষণ করা: fs.watch, fs.watchFile

ফাইল সিস্টেমের পরিবর্তনগুলি পর্যবেক্ষণ করা হট-রিলোডিং ডেভেলপমেন্ট সার্ভার, বিল্ড প্রক্রিয়া বা রিয়েল-টাইম ডেটা সিঙ্ক্রোনাইজেশনের মতো কাজগুলির জন্য অত্যাবশ্যক। Node.js এর জন্য দুটি প্রাথমিক পদ্ধতি সরবরাহ করে: fs.watch এবং fs.watchFile। TypeScript নিশ্চিত করে যে ইভেন্ট টাইপ এবং লিসেনার প্যারামিটারগুলি সঠিকভাবে পরিচালনা করা হয়েছে।

fs.watch: ইভেন্ট-ভিত্তিক ফাইল সিস্টেম পর্যবেক্ষণ

fs.watch সাধারণত আরও কার্যকর কারণ এটি প্রায়শই অপারেটিং সিস্টেম-স্তরের বিজ্ঞপ্তিগুলি ব্যবহার করে (যেমন, লিনাক্সে inotify, macOS এ kqueue, উইন্ডোজে ReadDirectoryChangesW)। এটি পরিবর্তন, মোছা বা পুনঃনামকরণের জন্য নির্দিষ্ট ফাইল বা ডিরেক্টরিগুলি পর্যবেক্ষণ করার জন্য উপযুক্ত।

import * as fs from 'fs'; const watchedFilePath: string = 'data/watched_file.txt'; const watchedDirPath: string = 'data/watched_dir'; // Ensure files/directories exist for watching fs.writeFileSync(watchedFilePath, 'Initial content.'); fs.mkdirSync(watchedDirPath, { recursive: true }); console.log(`Watching '${watchedFilePath}' for changes...`); const fileWatcher = fs.watch(watchedFilePath, (eventType: string, filename: string | Buffer | null) => { const fname = typeof filename === 'string' ? filename : filename?.toString('utf8'); console.log(`File '${fname || 'N/A'}' event: ${eventType}`); if (eventType === 'change') { console.log('File content potentially changed.'); } // In a real application, you might read the file here or trigger a rebuild }); console.log(`Watching directory '${watchedDirPath}' for changes...`); const dirWatcher = fs.watch(watchedDirPath, (eventType: string, filename: string | Buffer | null) => { const fname = typeof filename === 'string' ? filename : filename?.toString('utf8'); console.log(`Directory '${watchedDirPath}' event: ${eventType} on '${fname || 'N/A'}'`); }); fileWatcher.on('error', (err: Error) => console.error(`File watcher error: ${err.message}`)); dirWatcher.on('error', (err: Error) => console.error(`Directory watcher error: ${err.message}`)); // Simulate changes after a delay setTimeout(() => { console.log('\n--- Simulating changes ---'); fs.appendFileSync(watchedFilePath, '\nNew line added.'); fs.writeFileSync(`${watchedDirPath}/new_file.txt`, 'Content.'); fs.unlinkSync(`${watchedDirPath}/new_file.txt`); // Also test deletion setTimeout(() => { fileWatcher.close(); dirWatcher.close(); console.log('\nWatchers closed.'); // Clean up temporary files/dirs fs.unlinkSync(watchedFilePath); fs.rmSync(watchedDirPath, { recursive: true, force: true }); }, 2000); }, 1000);

fs.watch সম্পর্কে নোট: এটি সমস্ত প্ল্যাটফর্মে সমস্ত ধরণের ইভেন্টের জন্য সর্বদা নির্ভরযোগ্য নয় (উদাহরণস্বরূপ, ফাইলের নাম পরিবর্তনগুলিকে মোছা এবং তৈরি হিসাবে রিপোর্ট করা হতে পারে)। শক্তিশালী ক্রস-প্ল্যাটফর্ম ফাইল পর্যবেক্ষণের জন্য, chokidar এর মতো লাইব্রেরিগুলি বিবেচনা করুন, যা প্রায়শই আড়ালে fs.watch ব্যবহার করে তবে স্বাভাবিককরণ এবং ফলব্যাক মেকানিজম যোগ করে।

fs.watchFile: পোলিং-ভিত্তিক ফাইল পর্যবেক্ষণ

fs.watchFile পরিবর্তনগুলি সনাক্ত করতে পোলিং (পর্যায়ক্রমে ফাইলের stat ডেটা পরীক্ষা করা) ব্যবহার করে। এটি কম কার্যকর কিন্তু বিভিন্ন ফাইল সিস্টেম এবং নেটওয়ার্ক ড্রাইভ জুড়ে আরও সামঞ্জস্যপূর্ণ। এটি এমন পরিবেশের জন্য আরও উপযুক্ত যেখানে fs.watch নির্ভরযোগ্য নাও হতে পারে (যেমন, NFS শেয়ার)।

import * as fs from 'fs'; import { Stats } from 'fs'; const pollFilePath: string = 'data/polled_file.txt'; fs.writeFileSync(pollFilePath, 'Initial polled content.'); console.log(`Polling '${pollFilePath}' for changes...`); fs.watchFile(pollFilePath, { interval: 1000 }, (curr: Stats, prev: Stats) => { // TypeScript ensures 'curr' and 'prev' are fs.Stats objects if (curr.mtimeMs !== prev.mtimeMs) { console.log(`File '${pollFilePath}' modified (mtime changed). New size: ${curr.size} bytes.`); } }); setTimeout(() => { console.log('\n--- Simulating polled file change ---'); fs.appendFileSync(pollFilePath, '\nAnother line added to polled file.'); setTimeout(() => { fs.unwatchFile(pollFilePath); console.log(`\nStopped watching '${pollFilePath}'.`); fs.unlinkSync(pollFilePath); }, 2000); }, 1500);

বিশ্বব্যাপী প্রেক্ষাপটে ত্রুটি হ্যান্ডলিং এবং সর্বোত্তম অনুশীলন

যেকোনো প্রোডাকশন-রেডি অ্যাপ্লিকেশনের জন্য শক্তিশালী ত্রুটি হ্যান্ডলিং সর্বাগ্রে গুরুত্বপূর্ণ, বিশেষ করে যা ফাইল সিস্টেমের সাথে ইন্টারঅ্যাক্ট করে। ফাইল অপারেশনগুলি বিভিন্ন কারণে ব্যর্থ হতে পারে: অনুমতির সমস্যা, ডিস্ক পূর্ণ হওয়ার ত্রুটি, ফাইল খুঁজে না পাওয়া, I/O ত্রুটি, নেটওয়ার্ক সমস্যা (নেটওয়ার্ক-মাউন্টেড ড্রাইভের জন্য), বা যুগপত অ্যাক্সেস দ্বন্দ্ব। TypeScript আপনাকে টাইপ-সম্পর্কিত সমস্যাগুলি ধরতে সাহায্য করে, তবে রানটাইম ত্রুটিগুলির জন্য এখনও সতর্ক ব্যবস্থাপনার প্রয়োজন।

ত্রুটি হ্যান্ডলিং কৌশল

• সিঙ্ক্রোনাস অপারেশন: সর্বদা fs.xxxSync কলগুলিকে try...catch ব্লকগুলির মধ্যে রাখুন। এই পদ্ধতিগুলি সরাসরি ত্রুটিগুলি ছুঁড়ে দেয়।
• অ্যাসিঙ্ক্রোনাস কলব্যাক: একটি fs কলব্যাকের প্রথম আর্গুমেন্ট সর্বদা err: NodeJS.ErrnoException | null। সর্বদা প্রথমে এই err অবজেক্টটি পরীক্ষা করুন।
• প্রমিস-ভিত্তিক (fs/promises): প্রত্যাখ্যানগুলি পরিচালনা করার জন্য await সহ try...catch অথবা .then() চেইন সহ .catch() ব্যবহার করুন।

যদি আপনার অ্যাপ্লিকেশনের ত্রুটি প্রতিক্রিয়া ব্যবহারকারী-মুখী হয় তবে ত্রুটি লগিং ফরম্যাটগুলি মানসম্মত করা এবং ত্রুটি বার্তাগুলির জন্য আন্তর্জাতিকীকরণ (i18n) বিবেচনা করা উপকারী।

import * as fs from 'fs'; import { promises as fsPromises } from 'fs'; import * as path from 'path'; const problematicPath = path.join('non_existent_dir', 'file.txt'); // Synchronous error handling try { fs.readFileSync(problematicPath, 'utf8'); } catch (error: any) { console.error(`Sync Error: ${error.code} - ${error.message} (Path: ${problematicPath})`); } // Callback-based error handling fs.readFile(problematicPath, 'utf8', (err, data) => { if (err) { console.error(`Callback Error: ${err.code} - ${err.message} (Path: ${problematicPath})`); return; } // ... process data }); // Promise-based error handling async function safeReadFile(filePath: string): Promise { try { return await fsPromises.readFile(filePath, 'utf8'); } catch (error: any) { console.error(`Promise Error: ${error.code} - ${error.message} (Path: ${filePath})`); return null; } } safeReadFile(problematicPath).then(content => { if (content !== null) { // ... process content } });

রিসোর্স ম্যানেজমেন্ট: ফাইল ডিস্ক্রিপ্টর বন্ধ করা

fs.open (বা fsPromises.open) এর সাথে কাজ করার সময়, অপারেশনগুলি সম্পূর্ণ হওয়ার পরে, এমনকি ত্রুটি ঘটলেও, fs.close (বা fileHandle.close()) ব্যবহার করে ফাইল ডিস্ক্রিপ্টরগুলি সর্বদা বন্ধ করা হয়েছে তা নিশ্চিত করা অত্যন্ত গুরুত্বপূর্ণ। এটি করতে ব্যর্থ হলে রিসোর্স ফাঁস হতে পারে, অপারেটিং সিস্টেমের ওপেন ফাইল লিমিটে পৌঁছাতে পারে এবং সম্ভাব্যভাবে আপনার অ্যাপ্লিকেশন ক্র্যাশ করতে বা অন্যান্য প্রক্রিয়াকে প্রভাবিত করতে পারে।

FileHandle অবজেক্ট সহ fs/promises API সাধারণত এটিকে সরল করে, কারণ fileHandle.close() বিশেষভাবে এই উদ্দেশ্যে ডিজাইন করা হয়েছে এবং FileHandle ইনস্ট্যান্সগুলি Disposable (যদি Node.js 18.11.0+ এবং TypeScript 5.2+ ব্যবহার করা হয়)।

পাথ ম্যানেজমেন্ট এবং ক্রস-প্ল্যাটফর্ম সামঞ্জস্য

অপারেটিং সিস্টেমগুলির মধ্যে ফাইল পাথগুলি উল্লেখযোগ্যভাবে পরিবর্তিত হয় (যেমন, উইন্ডোজে \, ইউনিক্স-সদৃশ সিস্টেমে /)। Node.js path মডিউলটি ক্রস-প্ল্যাটফর্ম সামঞ্জস্যপূর্ণ উপায়ে ফাইল পাথ তৈরি এবং পার্স করার জন্য অপরিহার্য, যা বিশ্বব্যাপী স্থাপনার জন্য অত্যাবশ্যক।

• path.join(...paths): সমস্ত প্রদত্ত পাথ সেগমেন্টগুলিকে একত্রিত করে, ফলস্বরূপ পাথকে স্বাভাবিক করে।
• path.resolve(...paths): পাথ বা পাথ সেগমেন্টগুলির একটি ক্রমকে একটি অ্যাবসোলিউট পাথে রূপান্তর করে।
• path.basename(path): পাথের শেষ অংশটি ফিরিয়ে দেয়।
• path.dirname(path): পাথের ডিরেক্টরি নামটি ফিরিয়ে দেয়।
• path.extname(path): পাথের এক্সটেনশনটি ফিরিয়ে দেয়।

TypeScript path মডিউলের জন্য সম্পূর্ণ টাইপ সংজ্ঞা সরবরাহ করে, যা নিশ্চিত করে যে আপনি এর ফাংশনগুলি সঠিকভাবে ব্যবহার করছেন।

import * as path from 'path'; const dir = 'my_app_data'; const filename = 'config.json'; // Cross-platform path joining const fullPath: string = path.join(__dirname, dir, filename); console.log(`Cross-platform path: ${fullPath}`); // Get directory name const dirname: string = path.dirname(fullPath); console.log(`Directory name: ${dirname}`); // Get base file name const basename: string = path.basename(fullPath); console.log(`Base name: ${basename}`); // Get file extension const extname: string = path.extname(fullPath); console.log(`Extension: ${extname}`);

সমসাময়িকতা এবং রেস কন্ডিশন

যখন একাধিক অ্যাসিঙ্ক্রোনাস ফাইল অপারেশন যুগপৎভাবে শুরু করা হয়, বিশেষ করে লেখা বা মোছা, তখন রেস কন্ডিশন ঘটতে পারে। উদাহরণস্বরূপ, যদি একটি অপারেশন একটি ফাইলের অস্তিত্ব পরীক্ষা করে এবং অন্যটি প্রথম অপারেশনটি কাজ করার আগে এটি মুছে ফেলে, তখন প্রথম অপারেশনটি অপ্রত্যাশিতভাবে ব্যর্থ হতে পারে।

• গুরুত্বপূর্ণ পাথ লজিকের জন্য fs.existsSync পরিহার করুন; fs.access পছন্দ করুন বা কেবল অপারেশনটি চেষ্টা করুন এবং ত্রুটিটি পরিচালনা করুন।
• একচেটিয়া অ্যাক্সেসের প্রয়োজন এমন অপারেশনগুলির জন্য, উপযুক্ত flag অপশনগুলি ব্যবহার করুন (যেমন, একচেটিয়া লেখার জন্য 'wx')।
• অত্যন্ত গুরুত্বপূর্ণ শেয়ার্ড রিসোর্স অ্যাক্সেসের জন্য লকিং মেকানিজম (যেমন, ফাইল লক, বা অ্যাপ্লিকেশন-স্তরের লক) প্রয়োগ করুন, যদিও এটি জটিলতা বাড়ায়।

অনুমতি (ACLs)

ফাইল সিস্টেম অনুমতিগুলি (অ্যাক্সেস কন্ট্রোল লিস্ট বা স্ট্যান্ডার্ড ইউনিক্স অনুমতি) ত্রুটির একটি সাধারণ উৎস। নিশ্চিত করুন যে আপনার Node.js প্রক্রিয়াটির ফাইল এবং ডিরেক্টরি পড়া, লেখা বা কার্যকর করার জন্য প্রয়োজনীয় অনুমতি রয়েছে। এটি বিশেষত কন্টেইনারাইজড পরিবেশে বা বহু-ব্যবহারকারী সিস্টেমে প্রাসঙ্গিক যেখানে প্রক্রিয়াগুলি নির্দিষ্ট ব্যবহারকারী অ্যাকাউন্টের সাথে চলে।

উপসংহার: বিশ্বব্যাপী ফাইল সিস্টেম অপারেশনগুলির জন্য টাইপ সেফটি গ্রহণ করা

Node.js fs মডিউল ফাইল সিস্টেমের সাথে ইন্টারঅ্যাক্ট করার জন্য একটি শক্তিশালী এবং বহুমুখী সরঞ্জাম, যা মৌলিক ফাইল ম্যানিপুলেশন থেকে শুরু করে উন্নত স্ট্রিম-ভিত্তিক ডেটা প্রক্রিয়াকরণ পর্যন্ত বিভিন্ন বিকল্প সরবরাহ করে। এই অপারেশনগুলির উপরে TypeScript প্রয়োগ করে, আপনি অমূল্য সুবিধাগুলি লাভ করেন: কম্পাইল-টাইম ত্রুটি সনাক্তকরণ, উন্নত কোড স্বচ্ছতা, উচ্চতর টুলিং সমর্থন এবং রিফ্যাক্টরিংয়ের সময় বর্ধিত আত্মবিশ্বাস। এটি বিশ্বব্যাপী ডেভেলপমেন্ট দলগুলির জন্য বিশেষভাবে গুরুত্বপূর্ণ যেখানে বিভিন্ন কোডবেস জুড়ে ধারাবাহিকতা এবং অস্পষ্টতা হ্রাস করা অত্যাবশ্যক।

আপনি একটি ছোট ইউটিলিটি স্ক্রিপ্ট বা একটি বড় আকারের এন্টারপ্রাইজ অ্যাপ্লিকেশন তৈরি করছেন কিনা, আপনার Node.js ফাইল অপারেশনগুলির জন্য TypeScript-এর শক্তিশালী টাইপ সিস্টেম ব্যবহার করলে আরও রক্ষণাবেক্ষণযোগ্য, নির্ভরযোগ্য এবং ত্রুটি-প্রতিরোধী কোড তৈরি হবে। পরিষ্কার অ্যাসিঙ্ক্রোনাস প্যাটার্নগুলির জন্য fs/promises API গ্রহণ করুন, সিঙ্ক্রোনাস এবং অ্যাসিঙ্ক্রোনাস কলের মধ্যে সূক্ষ্ম পার্থক্যগুলি বুঝুন এবং সর্বদা শক্তিশালী ত্রুটি হ্যান্ডলিং এবং ক্রস-প্ল্যাটফর্ম পাথ ম্যানেজমেন্টকে অগ্রাধিকার দিন।

এই নির্দেশিকায় আলোচিত নীতি এবং উদাহরণগুলি প্রয়োগ করে, বিশ্বজুড়ে ডেভেলপাররা ফাইল সিস্টেম ইন্টারঅ্যাকশন তৈরি করতে পারেন যা কেবল কার্যকর এবং দক্ষ নয়, বরং স্বাভাবিকভাবেই আরও সুরক্ষিত এবং যুক্তিযুক্ত করা সহজ, যা শেষ পর্যন্ত উচ্চ মানের সফটওয়্যার সরবরাহে অবদান রাখে।