டைப்ஸ்கிரிப்ட் கோப்பு அமைப்புத் திறன்: உலகளாவிய டெவலப்பர்களுக்கான டைப் சேஃப்டியுடன் கூடிய நோட்.ஜே.எஸ் கோப்பு செயல்பாடுகள்

நவீன மென்பொருள் மேம்பாட்டின் பரந்த பரப்பில், Node.js ஆனது அளவிடக்கூடிய சேவையகப் பக்க பயன்பாடுகள், கட்டளை வரி கருவிகள் மற்றும் பலவற்றை உருவாக்குவதற்கான ஒரு சக்திவாய்ந்த இயங்குதளமாக நிற்கிறது. பல Node.js பயன்பாடுகளின் ஒரு அடிப்படை அம்சம் கோப்பு அமைப்புடன் – கோப்புகளைப் படித்தல், எழுதுதல், உருவாக்குதல் மற்றும் அடைவுகளை நிர்வகித்தல் – தொடர்புகொள்வதை உள்ளடக்கியது. ஜாவாஸ்கிரிப்ட் இந்த செயல்பாடுகளைக் கையாளும் நெகிழ்வுத்தன்மையை வழங்கினாலும், டைப்ஸ்கிரிப்ட்டின் அறிமுகம் நிலையான டைப் சரிபார்ப்பு, மேம்படுத்தப்பட்ட கருவிகள் மற்றும் இறுதியில், உங்கள் கோப்பு அமைப்பு குறியீட்டிற்கு அதிக நம்பகத்தன்மை மற்றும் பராமரிப்பை வழங்குவதன் மூலம் இந்த அனுபவத்தை உயர்த்துகிறது.

இந்த விரிவான வழிகாட்டி, கலாச்சார பின்னணி அல்லது புவியியல் இருப்பிடத்தைப் பொருட்படுத்தாமல், டைப்ஸ்கிரிப்ட் வழங்கும் வலிமையுடன் Node.js கோப்பு செயல்பாடுகளில் தேர்ச்சி பெற விரும்பும் உலகளாவிய டெவலப்பர்களுக்காக உருவாக்கப்பட்டுள்ளது. நாங்கள் முக்கிய `fs` தொகுதியில் ஆழமாக ஆராய்வோம், அதன் பல்வேறு ஒத்திசைவான மற்றும் ஒத்திசைவற்ற வழிமுறைகளை ஆராய்வோம், நவீன ப்ராமிஸ் அடிப்படையிலான APIகளை ஆய்வு செய்வோம், மேலும் டைப்ஸ்கிரிப்ட்டின் டைப் அமைப்பு பொதுவான பிழைகளைக் கணிசமாகக் குறைத்து உங்கள் குறியீட்டின் தெளிவை எவ்வாறு மேம்படுத்தலாம் என்பதைக் கண்டறிவோம்.

அடிப்படை: நோட்.ஜே.எஸ் கோப்பு அமைப்பைப் புரிந்துகொள்ளுதல் (`fs`)

Node.js `fs` தொகுதி, நிலையான POSIX செயல்பாடுகளை மாதிரியாகக் கொண்ட ஒரு கோப்பு அமைப்புடன் தொடர்புகொள்வதற்கான API ஐ வழங்குகிறது. இது அடிப்படை கோப்பு படித்தல் மற்றும் எழுதுதல் முதல் சிக்கலான அடைவு கையாளுதல்கள் மற்றும் கோப்பு கண்காணிப்பு வரை பலவிதமான முறைகளை வழங்குகிறது. பாரம்பரியமாக, இந்த செயல்பாடுகள் கால்பேக்குகள் மூலம் கையாளப்பட்டன, இது சிக்கலான சூழ்நிலைகளில் பிரபலமான "கால்பேக் ஹெல்"க்கு வழிவகுத்தது. Node.js இன் பரிணாம வளர்ச்சியுடன், ப்ராமிஸ்கள் மற்றும் `async/await` ஒத்திசைவற்ற செயல்பாடுகளுக்கான விருப்பமான வடிவங்களாக உருவெடுத்துள்ளன, குறியீட்டை மேலும் படிக்கக்கூடியதாகவும் நிர்வகிக்கக்கூடியதாகவும் ஆக்குகின்றன.

கோப்பு அமைப்பு செயல்பாடுகளுக்கு டைப்ஸ்கிரிப்ட் ஏன்?

Node.js இன் `fs` தொகுதி வெறும் ஜாவாஸ்கிரிப்ட்டுடன் சரியாகச் செயல்பட்டாலும், டைப்ஸ்கிரிப்ட்டை ஒருங்கிணைப்பது பல கவர்ச்சிகரமான நன்மைகளைத் தருகிறது:

• டைப் சேஃப்டி: தவறான ஆர்கியூமென்ட் டைப்கள், விடுபட்ட அளவுருக்கள் அல்லது எதிர்பாராத ரிட்டர்ன் மதிப்புகள் போன்ற பொதுவான பிழைகளை கம்பைல் நேரத்தில், உங்கள் குறியீடு இயங்கும் முன்பே கண்டறிகிறது. பல்வேறு கோப்பு குறியாக்கங்கள், கொடிகள் மற்றும் `Buffer` பொருட்களுடன் dealing செய்யும் போது இது விலைமதிப்பற்றது.
• மேம்படுத்தப்பட்ட படிக்கக்கூடிய தன்மை: வெளிப்படையான டைப் குறிப்புகள் ஒரு செயல்பாடு எந்த வகையான தரவை எதிர்பார்க்கிறது என்பதையும், அது எதை ரிட்டர்ன் செய்யும் என்பதையும் தெளிவாக்குகின்றன, இது பல்வேறு குழுக்களில் உள்ள டெவலப்பர்களுக்கு குறியீடு புரிதலை மேம்படுத்துகிறது.
• சிறந்த கருவிகள் & ஆட்டோகம்பிளிஷன்: IDEகள் (VS Code போன்றவை) டைப்ஸ்கிரிப்ட்டின் டைப் வரையறைகளைப் பயன்படுத்தி புத்திசாலித்தனமான ஆட்டோகம்பிளிஷன், அளவுரு குறிப்புகள் மற்றும் இன்லைன் ஆவணங்களை வழங்குகின்றன, இது உற்பத்தித்திறனை கணிசமாக அதிகரிக்கிறது.
• மறுசீரமைப்பு நம்பிக்கை: நீங்கள் ஒரு இன்டர்ஃபேஸையோ அல்லது ஒரு செயல்பாட்டு கையொப்பத்தையோ மாற்றும்போது, டைப்ஸ்கிரிப்ட் உடனடியாக பாதிக்கப்பட்ட அனைத்துப் பகுதிகளையும் கொடியிடுகிறது, இது பெரிய அளவிலான மறுசீரமைப்பைக் குறைவான பிழைக்கு வழிவகுக்கிறது.
• உலகளாவிய ஒருமைப்பாடு: சர்வதேச மேம்பாட்டுக் குழுக்களிடையே ஒரு சீரான குறியீட்டு நடை மற்றும் தரவு கட்டமைப்புகளைப் புரிந்துகொள்வதை உறுதிசெய்கிறது, தெளிவின்மையைக் குறைக்கிறது.

ஒத்திசைவான vs. ஒத்திசைவற்ற செயல்பாடுகள்: ஒரு உலகளாவிய கண்ணோட்டம்

ஒத்திசைவான மற்றும் ஒத்திசைவற்ற செயல்பாடுகளுக்கு இடையிலான வேறுபாட்டைப் புரிந்துகொள்வது மிக முக்கியம், குறிப்பாக செயல்திறன் மற்றும் உடனடி பதிலளிப்பு மிக முக்கியத்துவம் வாய்ந்த உலகளாவிய வரிசைப்படுத்தலுக்கான பயன்பாடுகளை உருவாக்கும் போது. பெரும்பாலான `fs` தொகுதி செயல்பாடுகள் ஒத்திசைவான மற்றும் ஒத்திசைவற்ற சுவைகளில் வருகின்றன. ஒரு கட்டைவிரல் விதியாக, Node.js சேவையகத்தின் பதிலளிப்பைப் பராமரிக்க அசிங்கரஸ் முறைகள் தடுக்காத I/O செயல்பாடுகளுக்கு விரும்பப்படுகின்றன.

• ஒத்திசைவற்ற (தடுக்காத): இந்த முறைகள் ஒரு கால்பேக் செயல்பாட்டை அவற்றின் கடைசி ஆர்கியூமென்ட்டாக எடுக்கின்றன அல்லது ஒரு `Promise`ஐ ரிட்டர்ன் செய்கின்றன. அவை கோப்பு அமைப்பு செயல்பாட்டைத் தொடங்கி உடனடியாகத் திரும்புகின்றன, இதனால் மற்ற குறியீடுகள் இயங்க அனுமதிக்கின்றன. செயல்பாடு முடிந்ததும், கால்பேக் அழைக்கப்படுகிறது (அல்லது Promise தீர்க்கப்படுகிறது/நிராகரிக்கப்படுகிறது). உலகெங்கிலும் உள்ள பயனர்களிடமிருந்து பல ஒரேநேர கோரிக்கைகளைக் கையாளும் சேவையகப் பயன்பாடுகளுக்கு இது சிறந்தது, ஏனெனில் இது ஒரு கோப்பு செயல்பாடு முடிவடையும் வரை காத்திருக்கும் போது சேவையகத்தை முடக்குவதைத் தடுக்கிறது.
• ஒத்திசைவான (தடுக்கும்): இந்த முறைகள் செயல்பாட்டைத் திரும்புவதற்கு முன்பு முழுமையாகச் செய்கின்றன. குறியிட எளிமையானது என்றாலும், அவை Node.js நிகழ்வு சுழற்சியைத் தடுக்கின்றன, கோப்பு அமைப்பு செயல்பாடு முடியும் வரை வேறு எந்த குறியீடும் இயங்குவதைத் தடுக்கின்றன. இது குறிப்பிடத்தக்க செயல்திறன் சிக்கல்களுக்கும் பதிலளிக்காத பயன்பாடுகளுக்கும் வழிவகுக்கும், குறிப்பாக அதிக போக்குவரத்து உள்ள சூழல்களில். பயன்பாட்டு தொடக்க தர்க்கம் அல்லது தடுப்பது ஏற்றுக்கொள்ளக்கூடிய எளிய ஸ்கிரிப்ட்களுக்கு அவற்றை அரிதாகவே பயன்படுத்தவும்.

டைப்ஸ்கிரிப்ட்டில் முக்கிய கோப்பு செயல்பாட்டு வகைகள்

பொதுவான கோப்பு அமைப்பு செயல்பாடுகளுடன் டைப்ஸ்கிரிப்ட்டின் நடைமுறை பயன்பாட்டில் delve செய்வோம். Node.js க்கான உள்ளமைக்கப்பட்ட டைப் வரையறைகளை நாங்கள் பயன்படுத்துவோம், அவை பொதுவாக `@types/node` தொகுப்பு மூலம் கிடைக்கின்றன.

தொடங்குவதற்கு, உங்கள் திட்டத்தில் டைப்ஸ்கிரிப்ட் மற்றும் 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`, மற்றும் Promises API

கோப்புகளிலிருந்து உள்ளடக்கத்தைப் படித்தல் ஒரு அடிப்படை செயல்பாடு ஆகும். கோப்புப் பாதைகள், குறியாக்கங்கள் மற்றும் சாத்தியமான பிழைகளை நீங்கள் சரியாகக் கையாளுகிறீர்கள் என்பதை டைப்ஸ்கிரிப்ட் உறுதிப்படுத்த உதவுகிறது.

ஒத்திசைவற்ற கோப்பு படித்தல் (கால்பேக் அடிப்படையிலானது)

`fs.readFile` செயல்பாடு ஒத்திசைவற்ற கோப்பு படித்தலுக்கு ஒரு பணிக்குதிரை. இது பாதை, ஒரு விருப்ப குறியாக்கம் மற்றும் ஒரு கால்பேக் செயல்பாட்டை எடுக்கிறது. கால்பேக்கின் ஆர்கியூமென்ட்கள் சரியாக டைப் செய்யப்பட்டுள்ளன என்பதை டைப்ஸ்கிரிப்ட் உறுதிசெய்கிறது (`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` ஆகும். டைப்ஸ்கிரிப்ட் இதை சரியாக ஊகிக்கிறது.

import * as 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 ஒரு தூய்மையான, ப்ராமிஸ் அடிப்படையிலான இன்டர்ஃபேஸை வழங்குகிறது, இது ஒத்திசைவற்ற செயல்பாடுகளுக்கு மிகவும் பரிந்துரைக்கப்படுகிறது. டைப்ஸ்கிரிப்ட் இங்கு சிறந்து விளங்குகிறது, குறிப்பாக `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`, மற்றும் கொடிகள் (Flags)

கோப்புகளுக்கு தரவை எழுதுவதும் சமமாக முக்கியமானது. கோப்புப் பாதைகள், தரவு வகைகள் (string அல்லது Buffer), குறியாக்கம் மற்றும் கோப்பு திறந்த கொடிகளை நிர்வகிக்க டைப்ஸ்கிரிப்ட் உதவுகிறது.

ஒத்திசைவற்ற கோப்பு எழுதுதல்

`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'` (append): சேர்க்க கோப்பைத் திறக்கவும். கோப்பு இல்லையென்றால் உருவாக்கப்படுகிறது.
• `'a+'`: படித்தல் மற்றும் சேர்ப்பதற்காக கோப்பைத் திறக்கவும். கோப்பு இல்லையென்றால் உருவாக்கப்படுகிறது.
• `'r'` (read): படித்தலுக்காக கோப்பைத் திறக்கவும். கோப்பு இல்லையென்றால் ஒரு விதிவிலக்கு நிகழ்கிறது.
• `'r+'`: படித்தல் மற்றும் எழுதுவதற்காக கோப்பைத் திறக்கவும். கோப்பு இல்லையென்றால் ஒரு விதிவிலக்கு நிகழ்கிறது.
• `'wx'` (exclusive write): `'w'` ஐப் போன்றது, ஆனால் பாதை இருந்தால் தோல்வியடைகிறது.
• `'ax'` (exclusive append): `'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`

கோப்பு அமைப்பிலிருந்து கோப்புகளை நீக்குதல். நீங்கள் ஒரு சரியான பாதையை அனுப்புகிறீர்கள் மற்றும் பிழைகளை சரியாகக் கையாளுகிறீர்கள் என்பதை டைப்ஸ்கிரிப்ட் உறுதிப்படுத்த உதவுகிறது.

ஒத்திசைவற்ற நீக்குதல்

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`

ஒரு கோப்பில் செயல்படுவதற்கு முன், அது இருக்கிறதா அல்லது தற்போதைய செயல்முறைக்கு தேவையான அனுமதிகள் உள்ளதா என்பதை நீங்கள் சரிபார்க்க வேண்டியிருக்கலாம். `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` செயல்பாடுகள் ஒரு கோப்பு அல்லது அடைவு பற்றிய விரிவான தகவல்களை வழங்குகின்றன, அதாவது அளவு, உருவாக்கப்பட்ட தேதி, மாற்றியமைக்கப்பட்ட தேதி மற்றும் அனுமதிகள். டைப்ஸ்கிரிப்ட்டின் `fs.Stats` இன்டர்ஃபேஸ் இந்த தரவுடன் செயல்படுவதை மிகவும் கட்டமைக்கப்பட்டதாகவும் நம்பகமானதாகவும் ஆக்குகிறது.

ஒத்திசைவற்ற ஸ்டாட் (Stat)

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 *s 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

டைப்ஸ்கிரிப்ட் மூலம் அடைவு செயல்பாடுகள்

அடைவுகளை நிர்வகிப்பது கோப்புகளை ஒழுங்கமைக்க, பயன்பாட்டு-குறிப்பிட்ட சேமிப்பகத்தை உருவாக்க அல்லது தற்காலிக தரவைக் கையாள ஒரு பொதுவான தேவை. இந்த செயல்பாடுகளுக்கு டைப்ஸ்கிரிப்ட் வலுவான டைப்பிங்கை வழங்குகிறது.

அடைவுகளை உருவாக்குதல்: `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 *s 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 *s 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 *s 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 })();

டைப்ஸ்கிரிப்ட் உடன் மேம்பட்ட கோப்பு அமைப்பு கருத்துகள்

அடிப்படை படித்தல்/எழுதுதல் செயல்பாடுகளுக்கு அப்பால், Node.js பெரிய கோப்புகளைக் கையாளுவதற்கும், தொடர்ச்சியான தரவு ஓட்டங்களுக்கும், கோப்பு அமைப்பின் நிகழ்நேர கண்காணிப்பிற்கும் சக்திவாய்ந்த அம்சங்களை வழங்குகிறது. டைப்ஸ்கிரிப்ட்டின் டைப் அறிவிப்புகள் இந்த மேம்பட்ட சூழ்நிலைகளுக்கு இணக்கமாக விரிவடைந்து, வலிமையை உறுதி செய்கின்றன.

கோப்பு விளக்கங்கள் மற்றும் ஸ்ட்ரீம்கள்

மிகப்பெரிய கோப்புகளுக்கு அல்லது கோப்பு அணுகல் (எ.கா., ஒரு கோப்பில் குறிப்பிட்ட நிலைகள்) மீது துல்லியமான கட்டுப்பாடு தேவைப்படும்போது, கோப்பு விளக்கங்களும் ஸ்ட்ரீம்களும் அத்தியாவசியமாகின்றன. ஸ்ட்ரீம்கள், முழு கோப்பையும் நினைவகத்தில் ஏற்றாமல், பெரிய அளவிலான தரவுகளைத் துண்டுகளாகப் படிப்பதற்கோ அல்லது எழுதுவதற்கோ ஒரு திறமையான வழியை வழங்குகின்றன, இது உலகளவில் சேவையகங்களில் அளவிடக்கூடிய பயன்பாடுகள் மற்றும் திறமையான வள மேலாண்மைக்கு முக்கியமானது.

விளக்கங்களுடன் கோப்புகளைத் திறத்தல் மற்றும் மூடுதல் (`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 உடன் தடையின்றி ஒருங்கிணைக்கப்படுகின்றன. டைப்ஸ்கிரிப்ட் இந்த ஸ்ட்ரீம் நிகழ்வுகளுக்கு (எ.கா., `'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`. நிகழ்வு வகைகள் மற்றும் லிசனர் அளவுருக்கள் சரியாகக் கையாளப்படுவதை டைப்ஸ்கிரிப்ட் உறுதிசெய்கிறது.

`fs.watch`: நிகழ்வு அடிப்படையிலான கோப்பு அமைப்பு கண்காணிப்பு

`fs.watch` பொதுவாக மிகவும் திறமையானது, ஏனெனில் இது பெரும்பாலும் இயக்க முறைமை அளவிலான அறிவிப்புகளைப் பயன்படுத்துகிறது (எ.கா., Linux இல் `inotify`, macOS இல் `kqueue`, Windows இல் `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 பிழைகள், நெட்வொர்க் சிக்கல்கள் (நெட்வொர்க்-மவுண்ட் செய்யப்பட்ட டிரைவ்களுக்கு), அல்லது ஒரேநேர அணுகல் மோதல்கள். டைப்-சம்பந்தப்பட்ட சிக்கல்களைக் கண்டறிய டைப்ஸ்கிரிப்ட் உங்களுக்கு உதவுகிறது, ஆனால் இயக்க நேர பிழைகளுக்கு கவனமாக மேலாண்மை தேவை.

பிழை கையாளுதல் உத்திகள்

• ஒத்திசைவான செயல்பாடுகள்: `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+ மற்றும் டைப்ஸ்கிரிப்ட் 5.2+ ஐப் பயன்படுத்தினால்).

பாதை மேலாண்மை மற்றும் குறுக்கு-தளம் இணக்கத்தன்மை

கோப்புப் பாதைகள் இயக்க முறைமைகளுக்கு இடையே கணிசமாக வேறுபடுகின்றன (எ.கா., Windows இல் `\`, Unix-போன்ற அமைப்புகளில் `/`). Node.js `path` தொகுதி குறுக்கு-தளம் இணக்கமான வழியில் கோப்புப் பாதைகளை உருவாக்குவதற்கும் பகுப்பாய்வு செய்வதற்கும் இன்றியமையாதது, இது உலகளாவிய வரிசைப்படுத்தல்களுக்கு அவசியமானது.

• `path.join(...paths)`: அனைத்து கொடுக்கப்பட்ட பாதை பிரிவுகளையும் ஒன்றாக இணைத்து, விளைந்த பாதையை இயல்பாக்குகிறது.
• `path.resolve(...paths)`: ஒரு பாதை அல்லது பாதை பிரிவுகளின் வரிசையை ஒரு முழுமையான பாதையாக தீர்க்கிறது.
• `path.basename(path)`: ஒரு பாதையின் கடைசிப் பகுதியைக் காட்டுகிறது.
• `path.dirname(path)`: ஒரு பாதையின் அடைவுப் பெயரைக் காட்டுகிறது.
• `path.extname(path)`: ஒரு பாதையின் நீட்டிப்பைக் காட்டுகிறது.

டைப்ஸ்கிரிப்ட் `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)

கோப்பு அமைப்பு அனுமதிகள் (அணுகல் கட்டுப்பாட்டுப் பட்டியல்கள் அல்லது நிலையான Unix அனுமதிகள்) பிழைகளின் ஒரு பொதுவான ஆதாரமாகும். உங்கள் Node.js செயல்முறைக்கு கோப்புகள் மற்றும் அடைவுகளைப் படிக்க, எழுத அல்லது இயக்க தேவையான அனுமதிகள் இருப்பதை உறுதிப்படுத்தவும். இது கொள்கலன் சூழல்களில் அல்லது செயல்முறைகள் குறிப்பிட்ட பயனர் கணக்குகளுடன் இயங்கும் பல-பயனர் அமைப்புகளில் குறிப்பாக பொருத்தமானது.

முடிவுரை: உலகளாவிய கோப்பு அமைப்பு செயல்பாடுகளுக்கான டைப் சேஃப்டியைத் தழுவுதல்

Node.js `fs` தொகுதி, கோப்பு அமைப்புடன் தொடர்புகொள்வதற்கான ஒரு சக்திவாய்ந்த மற்றும் பல்துறை கருவியாகும், இது அடிப்படை கோப்பு கையாளுதல்கள் முதல் மேம்பட்ட ஸ்ட்ரீம் அடிப்படையிலான தரவு செயலாக்கம் வரை பல விருப்பங்களை வழங்குகிறது. இந்த செயல்பாடுகளின் மேல் டைப்ஸ்கிரிப்ட்டை அடுக்குவதன் மூலம், நீங்கள் விலைமதிப்பற்ற நன்மைகளைப் பெறுகிறீர்கள்: கம்பைல்-நேர பிழை கண்டறிதல், மேம்படுத்தப்பட்ட குறியீடு தெளிவு, சிறந்த கருவி ஆதரவு மற்றும் மறுசீரமைப்பின் போது அதிகரித்த நம்பிக்கை. இது உலகளாவிய மேம்பாட்டுக் குழுக்களுக்கு குறிப்பாக முக்கியமானது, அங்கு பல்வேறு குறியீட்டுத் தளங்களில் நிலைத்தன்மை மற்றும் குறைந்த தெளிவின்மை மிக முக்கியம்.

நீங்கள் ஒரு சிறிய பயன்பாட்டு ஸ்கிரிப்டை உருவாக்கினாலும் அல்லது ஒரு பெரிய அளவிலான நிறுவனப் பயன்பாட்டை உருவாக்கினாலும், உங்கள் Node.js கோப்பு செயல்பாடுகளுக்கு டைப்ஸ்கிரிப்ட்டின் வலுவான டைப் அமைப்பைப் பயன்படுத்துவது அதிக பராமரிக்கக்கூடிய, நம்பகமான மற்றும் பிழை-எதிர்ப்பு குறியீட்டிற்கு வழிவகுக்கும். தூய்மையான ஒத்திசைவற்ற வடிவங்களுக்கு `fs/promises` API ஐத் தழுவுங்கள், ஒத்திசைவான மற்றும் ஒத்திசைவற்ற அழைப்புகளுக்கு இடையிலான நுணுக்கங்களைப் புரிந்து கொள்ளுங்கள், மேலும் எப்போதும் வலுவான பிழை கையாளுதல் மற்றும் குறுக்கு-தளம் பாதை மேலாண்மைக்கு முன்னுரிமை கொடுங்கள்.

இந்த வழிகாட்டியில் விவாதிக்கப்பட்ட கோட்பாடுகளையும் எடுத்துக்காட்டுகளையும் பயன்படுத்துவதன் மூலம், உலகெங்கிலும் உள்ள டெவலப்பர்கள் செயல்திறன் மற்றும் திறமையானது மட்டுமல்லாமல், உள்ளார்ந்த பாதுகாப்பான மற்றும் எளிதில் புரிந்து கொள்ளக்கூடிய கோப்பு அமைப்பு தொடர்புகளை உருவாக்க முடியும், இது இறுதியில் உயர்தர மென்பொருள் விநியோகங்களுக்கு பங்களிக்கும்.