టైప్‌స్క్రిప్ట్‌తో శక్తివంతమైన నోడ్.js ఫైల్ ఆపరేషన్స్‌ను అన్‌లాక్ చేయండి. ఈ సమగ్ర గైడ్ సింక్రోనస్, అసింక్రోనస్, మరియు స్ట్రీమ్-ఆధారిత FS పద్ధతులను వివరిస్తుంది, టైప్ సేఫ్టీ, ఎర్రర్ హ్యాండ్లింగ్, మరియు గ్లోబల్ డెవలప్‌మెంట్ బృందాల కోసం ఉత్తమ పద్ధతులను నొక్కి చెబుతుంది.
టైప్‌స్క్రిప్ట్ ఫైల్ సిస్టమ్ నైపుణ్యం: గ్లోబల్ డెవలపర్‌ల కోసం టైప్ సేఫ్టీతో నోడ్.js ఫైల్ ఆపరేషన్స్
ఆధునిక సాఫ్ట్‌వేర్ డెవలప్‌మెంట్ యొక్క విస్తారమైన ప్రపంచంలో, స్కేలబుల్ సర్వర్-సైడ్ అప్లికేషన్‌లు, కమాండ్-లైన్ టూల్స్ మరియు మరెన్నో నిర్మించడానికి నోడ్.js ఒక శక్తివంతమైన రన్‌టైమ్‌గా నిలుస్తుంది. అనేక నోడ్.js అప్లికేషన్‌లలో ఒక ప్రాథమిక అంశం ఫైల్ సిస్టమ్‌తో ఇంటరాక్ట్ అవ్వడం – ఫైల్స్ మరియు డైరెక్టరీలను చదవడం, రాయడం, సృష్టించడం మరియు నిర్వహించడం. జావాస్క్రిప్ట్ ఈ ఆపరేషన్‌లను నిర్వహించడానికి ఫ్లెక్సిబిలిటీని అందిస్తుండగా, టైప్‌స్క్రిప్ట్ పరిచయం స్టాటిక్ టైప్-చెకింగ్, మెరుగైన టూలింగ్, మరియు చివరికి, మీ ఫైల్ సిస్టమ్ కోడ్‌కు ఎక్కువ విశ్వసనీయత మరియు నిర్వహణ సౌలభ్యాన్ని తీసుకువచ్చి ఈ అనుభవాన్ని ఉన్నత స్థాయికి తీసుకువెళుతుంది.
ఈ సమగ్ర గైడ్, వారి సాంస్కృతిక నేపథ్యం లేదా భౌగోళిక స్థానంతో సంబంధం లేకుండా, ప్రపంచవ్యాప్తంగా ఉన్న డెవలపర్‌ల కోసం రూపొందించబడింది, వారు టైప్‌స్క్రిప్ట్ అందించే పటిష్టతతో నోడ్.js ఫైల్ ఆపరేషన్స్‌లో నైపుణ్యం సాధించాలని కోరుకుంటారు. మేము కోర్ `fs` మాడ్యూల్‌లోకి లోతుగా వెళ్తాము, దాని వివిధ సింక్రోనస్ మరియు అసింక్రోనస్ పద్ధతులను అన్వేషిస్తాము, ఆధునిక ప్రామిస్-ఆధారిత APIలను పరిశీలిస్తాము మరియు టైప్‌స్క్రిప్ట్ యొక్క టైప్ సిస్టమ్ సాధారణ ఎర్రర్‌లను గణనీయంగా ఎలా తగ్గిస్తుందో మరియు మీ కోడ్ యొక్క స్పష్టతను ఎలా మెరుగుపరుస్తుందో కనుగొంటాము.
మూలస్తంభం: నోడ్.js ఫైల్ సిస్టమ్ (`fs`)ను అర్థం చేసుకోవడం
నోడ్.js `fs` మాడ్యూల్, ప్రామాణిక POSIX ఫంక్షన్‌ల ఆధారంగా ఫైల్ సిస్టమ్‌తో ఇంటరాక్ట్ అవ్వడానికి ఒక APIని అందిస్తుంది. ఇది ప్రాథమిక ఫైల్ రీడ్స్ మరియు రైట్స్ నుండి సంక్లిష్టమైన డైరెక్టరీ మానిప్యులేషన్‌లు మరియు ఫైల్ వాచింగ్ వరకు విస్తృతమైన పద్ధతులను అందిస్తుంది. సాంప్రదాయకంగా, ఈ ఆపరేషన్‌లు కాల్‌బ్యాక్‌లతో నిర్వహించబడేవి, ఇది సంక్లిష్టమైన సందర్భాలలో "కాల్‌బ్యాక్ హెల్"కు దారితీసింది. నోడ్.js పరిణామంతో, ప్రామిసెస్ మరియు `async/await` అసింక్రోనస్ ఆపరేషన్ల కోసం ఇష్టపడే పద్ధతులుగా ఉద్భవించాయి, ఇది కోడ్‌ను మరింత చదవగలిగేలా మరియు నిర్వహించగలిగేలా చేస్తుంది.
ఫైల్ సిస్టమ్ ఆపరేషన్స్ కోసం టైప్‌స్క్రిప్ట్ ఎందుకు?
నోడ్.js యొక్క `fs` మాడ్యూల్ సాదా జావాస్క్రిప్ట్‌తో సంపూర్ణంగా పనిచేస్తున్నప్పటికీ, టైప్‌స్క్రిప్ట్‌ను ఏకీకృతం చేయడం అనేక బలమైన ప్రయోజనాలను అందిస్తుంది:
- టైప్ సేఫ్టీ: మీ కోడ్ రన్ అవ్వడానికి ముందే, కంపైల్ సమయంలోనే తప్పు ఆర్గ్యుమెంట్ రకాలు, మిస్సింగ్ పారామీటర్లు లేదా ఊహించని రిటర్న్ విలువల వంటి సాధారణ ఎర్రర్‌లను పట్టుకుంటుంది. ఇది వివిధ ఫైల్ ఎన్‌కోడింగ్‌లు, ఫ్లాగ్‌లు మరియు `Buffer` ఆబ్జెక్ట్‌లతో వ్యవహరించేటప్పుడు అమూల్యమైనది.
- మెరుగైన చదవడానికి వీలు: స్పష్టమైన టైప్ అనోటేషన్లు ఒక ఫంక్షన్ ఏ రకమైన డేటాను ఆశిస్తుందో మరియు ఏమి తిరిగి ఇస్తుందో స్పష్టం చేస్తాయి, విభిన్న బృందాలలోని డెవలపర్‌లకు కోడ్ అవగాహనను మెరుగుపరుస్తాయి.
- మెరుగైన టూలింగ్ & ఆటోకంప్లీషన్: IDEలు (VS కోడ్ వంటివి) టైప్‌స్క్రిప్ట్ యొక్క టైప్ డెఫినిషన్‌లను ఉపయోగించి ఇంటెలిజెంట్ ఆటోకంప్లీషన్, పారామీటర్ సూచనలు, మరియు ఇన్‌లైన్ డాక్యుమెంటేషన్‌ను అందిస్తాయి, ఇది ఉత్పాదకతను గణనీయంగా పెంచుతుంది.
- రిఫ్యాక్టరింగ్ విశ్వాసం: మీరు ఒక ఇంటర్‌ఫేస్ లేదా ఫంక్షన్ సిగ్నేచర్‌ను మార్చినప్పుడు, టైప్‌స్క్రిప్ట్ వెంటనే ప్రభావితమైన అన్ని ప్రాంతాలను ఫ్లాగ్ చేస్తుంది, పెద్ద-స్థాయి రిఫ్యాక్టరింగ్‌ను తక్కువ ఎర్రర్-ప్రోన్‌గా చేస్తుంది.
- గ్లోబల్ స్థిరత్వం: అంతర్జాతీయ డెవలప్‌మెంట్ బృందాల అంతటా కోడింగ్ శైలి మరియు డేటా స్ట్రక్చర్‌ల అవగాహనలో స్థిరత్వాన్ని నిర్ధారిస్తుంది, అస్పష్టతను తగ్గిస్తుంది.
సింక్రోనస్ వర్సెస్ అసింక్రోనస్ ఆపరేషన్స్: ఒక గ్లోబల్ దృక్పథం
సింక్రోనస్ మరియు అసింక్రోనస్ ఆపరేషన్ల మధ్య వ్యత్యాసాన్ని అర్థం చేసుకోవడం చాలా ముఖ్యం, ముఖ్యంగా పనితీరు మరియు ప్రతిస్పందన చాలా ముఖ్యమైన గ్లోబల్ డిప్లాయ్‌మెంట్ కోసం అప్లికేషన్‌లను నిర్మించేటప్పుడు. చాలా `fs` మాడ్యూల్ ఫంక్షన్‌లు సింక్రోనస్ మరియు అసింక్రోనస్ వేరియంట్‌లలో వస్తాయి. సాధారణ నియమంగా, నాన్-బ్లాకింగ్ I/O ఆపరేషన్ల కోసం అసింక్రోనస్ పద్ధతులు ఇష్టపడబడతాయి, ఇవి మీ నోడ్.js సర్వర్ యొక్క ప్రతిస్పందనను నిర్వహించడానికి అవసరం.
- అసింక్రోనస్ (నాన్-బ్లాకింగ్): ఈ పద్ధతులు తమ చివరి ఆర్గ్యుమెంట్‌గా ఒక కాల్‌బ్యాక్ ఫంక్షన్‌ను తీసుకుంటాయి లేదా ఒక `Promise`ను తిరిగి ఇస్తాయి. అవి ఫైల్ సిస్టమ్ ఆపరేషన్‌ను ప్రారంభించి వెంటనే తిరిగి వస్తాయి, ఇతర కోడ్ అమలు చేయడానికి అనుమతిస్తాయి. ఆపరేషన్ పూర్తయినప్పుడు, కాల్‌బ్యాక్ పిలువబడుతుంది (లేదా Promise రిసాల్వ్/రిజెక్ట్ అవుతుంది). ఇది ప్రపంచవ్యాప్తంగా ఉన్న వినియోగదారుల నుండి బహుళ ఏకకాల అభ్యర్థనలను నిర్వహించే సర్వర్ అప్లికేషన్‌లకు ఆదర్శంగా ఉంటుంది, ఎందుకంటే ఇది ఫైల్ ఆపరేషన్ పూర్తి కావడానికి వేచి ఉండగా సర్వర్ ఫ్రీజ్ అవ్వకుండా నిరోధిస్తుంది.
- సింక్రోనస్ (బ్లాకింగ్): ఈ పద్ధతులు తిరిగి వచ్చే ముందు ఆపరేషన్‌ను పూర్తిగా నిర్వహిస్తాయి. కోడ్ చేయడానికి సరళంగా ఉన్నప్పటికీ, అవి నోడ్.js ఈవెంట్ లూప్‌ను బ్లాక్ చేస్తాయి, ఫైల్ సిస్టమ్ ఆపరేషన్ పూర్తయ్యే వరకు ఏ ఇతర కోడ్ రన్ అవ్వకుండా నిరోధిస్తాయి. ఇది ముఖ్యంగా అధిక-ట్రాఫిక్ వాతావరణాలలో గణనీయమైన పనితీరు అడ్డంకులకు మరియు ప్రతిస్పందించని అప్లికేషన్‌లకు దారితీయవచ్చు. వాటిని చాలా తక్కువగా వాడండి, సాధారణంగా అప్లికేషన్ స్టార్టప్ లాజిక్ లేదా బ్లాకింగ్ ఆమోదయోగ్యమైన సాధారణ స్క్రిప్ట్‌ల కోసం.
టైప్‌స్క్రిప్ట్‌లో కోర్ ఫైల్ ఆపరేషన్ రకాలు
సాధారణ ఫైల్ సిస్టమ్ ఆపరేషన్లతో టైప్‌స్క్రిప్ట్ యొక్క ఆచరణాత్మక అప్లికేషన్‌లోకి ప్రవేశిద్దాం. మేము నోడ్.js కోసం అంతర్నిర్మిత టైప్ డెఫినిషన్‌లను ఉపయోగిస్తాము, ఇవి సాధారణంగా `@types/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
ఫైళ్ల నుండి కంటెంట్‌ను చదవడం ఒక ప్రాథమిక ఆపరేషన్. ఫైల్ పాత్‌లు, ఎన్‌కోడింగ్‌లు మరియు సంభావ్య ఎర్రర్‌లను మీరు సరిగ్గా నిర్వహించేలా టైప్‌స్క్రిప్ట్ సహాయపడుతుంది.
అసింక్రోనస్ ఫైల్ రీడ్ (కాల్‌బ్యాక్-ఆధారిత)
`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) {
// అంతర్జాతీయ డీబగ్గింగ్ కోసం ఎర్రర్‌ను లాగ్ చేయండి, ఉదా., 'File not found'
console.error(`ఫైల్ '${filePath}' చదవడంలో ఎర్రర్: ${err.message}`);
return;
}
// 'utf8' ఎన్‌కోడింగ్ ప్రకారం ఫైల్ కంటెంట్ ఒక స్ట్రింగ్ అని నిర్ధారించుకుని ప్రాసెస్ చేయండి
console.log(`ఫైల్ కంటెంట్ (${filePath}):\n${data}`);
});
// ఉదాహరణ: బైనరీ డేటాను చదవడం (ఎన్‌కోడింగ్ పేర్కొనబడలేదు)
const binaryFilePath: string = 'data/image.png';
fs.readFile(binaryFilePath, (err: NodeJS.ErrnoException | null, data: Buffer) => {
if (err) {
console.error(`బైనరీ ఫైల్ '${binaryFilePath}' చదవడంలో ఎర్రర్: ${err.message}`);
return;
}
// ఇక్కడ 'data' ఒక Buffer, తదుపరి ప్రాసెసింగ్ కోసం సిద్ధంగా ఉంది (ఉదా., క్లయింట్‌కు స్ట్రీమింగ్)
console.log(`${binaryFilePath} నుండి ${data.byteLength} బైట్‌లు చదవబడ్డాయి`);
});
సింక్రోనస్ ఫైల్ రీడ్
`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(`సింక్రోనస్ రీడ్ కంటెంట్ (${syncFilePath}):\n${content}`);
} catch (error: any) {
console.error(`'${syncFilePath}' కోసం సింక్రోనస్ రీడ్ ఎర్రర్: ${error.message}`);
}
ప్రామిస్-ఆధారిత ఫైల్ రీడ్ (`fs/promises`)
ఆధునిక `fs/promises` API ఒక క్లీనర్, ప్రామిస్-ఆధారిత ఇంటర్‌ఫేస్‌ను అందిస్తుంది, ఇది అసింక్రోనస్ ఆపరేషన్ల కోసం అత్యంత సిఫార్సు చేయబడింది. టైప్‌స్క్రిప్ట్ ఇక్కడ, ముఖ్యంగా `async/await`తో అద్భుతంగా పనిచేస్తుంది.
import * as fsPromises from 'fs/promises';
async function readTextFile(path: string): Promise
ఫైళ్లను రాయడం: `writeFile`, `writeFileSync`, మరియు ఫ్లాగ్స్
ఫైళ్లకు డేటాను రాయడం కూడా అంతే ముఖ్యం. ఫైల్ పాత్‌లు, డేటా రకాలు (స్ట్రింగ్ లేదా బఫర్), ఎన్‌కోడింగ్ మరియు ఫైల్ ఓపెన్ ఫ్లాగ్‌లను నిర్వహించడానికి టైప్‌స్క్రిప్ట్ సహాయపడుతుంది.
అసింక్రోనస్ ఫైల్ రైట్
`fs.writeFile` ఒక ఫైల్‌కు డేటాను రాయడానికి ఉపయోగించబడుతుంది, ఇది డిఫాల్ట్‌గా ఇప్పటికే ఉన్నట్లయితే ఫైల్‌ను భర్తీ చేస్తుంది. మీరు ఈ ప్రవర్తనను `flags`తో నియంత్రించవచ్చు.
import * as fs from 'fs';
const outputFilePath: string = 'data/output.txt';
const fileContent: string = 'ఇది టైప్‌స్క్రిప్ట్ ద్వారా వ్రాయబడిన కొత్త కంటెంట్.';
fs.writeFile(outputFilePath, fileContent, 'utf8', (err: NodeJS.ErrnoException | null) => {
if (err) {
console.error(`ఫైల్ '${outputFilePath}' రాయడంలో ఎర్రర్: ${err.message}`);
return;
}
console.log(`ఫైల్ '${outputFilePath}' విజయవంతంగా వ్రాయబడింది.`);
});
// Buffer డేటాతో ఉదాహరణ
const bufferContent: Buffer = Buffer.from('బైనరీ డేటా ఉదాహరణ');
const binaryOutputFilePath: string = 'data/binary_output.bin';
fs.writeFile(binaryOutputFilePath, bufferContent, (err: NodeJS.ErrnoException | null) => {
if (err) {
console.error(`బైనరీ ఫైల్ '${binaryOutputFilePath}' రాయడంలో ఎర్రర్: ${err.message}`);
return;
}
console.log(`బైనరీ ఫైల్ '${binaryOutputFilePath}' విజయవంతంగా వ్రాయబడింది.`);
});
సింక్రోనస్ ఫైల్ రైట్
`fs.writeFileSync` రైట్ ఆపరేషన్ పూర్తయ్యే వరకు ఈవెంట్ లూప్‌ను బ్లాక్ చేస్తుంది.
import * as fs from 'fs';
const syncOutputFilePath: string = 'data/sync_output.txt';
try {
fs.writeFileSync(syncOutputFilePath, 'సింక్రోనస్‌గా వ్రాసిన కంటెంట్.', 'utf8');
console.log(`ఫైల్ '${syncOutputFilePath}' సింక్రోనస్‌గా వ్రాయబడింది.`);
} catch (error: any) {
console.error(`'${syncOutputFilePath}' కోసం సింక్రోనస్ రైట్ ఎర్రర్: ${error.message}`);
}
ప్రామిస్-ఆధారిత ఫైల్ రైట్ (`fs/promises`)
అసింక్రోనస్ రైట్‌లను నిర్వహించడానికి `async/await` మరియు `fs/promises`తో కూడిన ఆధునిక విధానం తరచుగా క్లీనర్‌గా ఉంటుంది.
import * as fsPromises from 'fs/promises';
import { constants as fsConstants } from 'fs'; // ఫ్లాగ్స్ కోసం
async function writeDataToFile(path: string, data: string | Buffer): Promise
ముఖ్యమైన ఫ్లాగ్‌లు:
- `'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(`లాగ్ ఫైల్ '${logFilePath}'కు జోడించడంలో ఎర్రర్: ${err.message}`);
return;
}
console.log(`'${logFilePath}'కు సందేశం లాగ్ చేయబడింది.`);
});
}
logMessage('యూజర్ "Alice" లాగిన్ అయ్యారు.');
setTimeout(() => logMessage('సిస్టమ్ అప్‌డేట్ ప్రారంభించబడింది.'), 50);
logMessage('డేటాబేస్ కనెక్షన్ స్థాపించబడింది.');
సింక్రోనస్ అపెండ్
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(`'${syncLogFilePath}'కు సందేశం సింక్రోనస్‌గా లాగ్ చేయబడింది.`);
} catch (error: any) {
console.error(`లాగ్ ఫైల్ '${syncLogFilePath}'కు సింక్రోనస్‌గా జోడించడంలో ఎర్రర్: ${error.message}`);
}
}
logMessageSync('అప్లికేషన్ ప్రారంభించబడింది.');
logMessageSync('కాన్ఫిగరేషన్ లోడ్ చేయబడింది.');
ప్రామిస్-ఆధారిత అపెండ్ (`fs/promises`)
import * as fsPromises from 'fs/promises';
const promiseLogFilePath: string = 'data/promise_app_logs.log';
async function logMessagePromise(message: string): Promise
ఫైళ్లను తొలగించడం: `unlink`, `unlinkSync`
ఫైల్ సిస్టమ్ నుండి ఫైళ్లను తొలగించడం. మీరు చెల్లుబాటు అయ్యే పాత్‌ను పంపుతున్నారని మరియు ఎర్రర్‌లను సరిగ్గా హ్యాండిల్ చేస్తున్నారని నిర్ధారించుకోవడానికి టైప్‌స్క్రిప్ట్ సహాయపడుతుంది.
అసింక్రోనస్ డిలీట్
import * as fs from 'fs';
const fileToDeletePath: string = 'data/temp_to_delete.txt';
// మొదట, తొలగింపు డెమో కోసం ఫైల్ ఉనికిలో ఉందని నిర్ధారించడానికి దాన్ని సృష్టించండి
fs.writeFile(fileToDeletePath, 'తాత్కాలిక కంటెంట్.', 'utf8', (err) => {
if (err) {
console.error('తొలగింపు డెమో కోసం ఫైల్‌ను సృష్టించడంలో ఎర్రర్:', err);
return;
}
console.log(`తొలగింపు డెమో కోసం ఫైల్ '${fileToDeletePath}' సృష్టించబడింది.`);
fs.unlink(fileToDeletePath, (err: NodeJS.ErrnoException | null) => {
if (err) {
console.error(`ఫైల్ '${fileToDeletePath}' తొలగించడంలో ఎర్రర్: ${err.message}`);
return;
}
console.log(`ఫైల్ '${fileToDeletePath}' విజయవంతంగా తొలగించబడింది.`);
});
});
సింక్రోనస్ డిలీట్
import * as fs from 'fs';
const syncFileToDeletePath: string = 'data/sync_temp_to_delete.txt';
try {
fs.writeFileSync(syncFileToDeletePath, 'సింక్ టెంప్ కంటెంట్.', 'utf8');
console.log(`ఫైల్ '${syncFileToDeletePath}' సృష్టించబడింది.`);
fs.unlinkSync(syncFileToDeletePath);
console.log(`ఫైల్ '${syncFileToDeletePath}' సింక్రోనస్‌గా తొలగించబడింది.`);
} catch (error: any) {
console.error(`'${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
ఫైల్ ఉనికి మరియు అనుమతులను తనిఖీ చేయడం: `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(`ఫైల్ '${checkFilePath}' ఉనికిలో ఉంది.`);
} else {
console.log(`ఫైల్ '${checkFilePath}' ఉనికిలో లేదు.`);
}
అసింక్రోనస్ అనుమతి తనిఖీ (`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(`ఫైల్ '${accessFilePath}' ఉనికిలో లేదు లేదా యాక్సెస్ నిరాకరించబడింది.`);
return;
}
console.log(`ఫైల్ '${accessFilePath}' ఉనికిలో ఉంది.`);
});
fs.access(accessFilePath, constants.R_OK | constants.W_OK, (err: NodeJS.ErrnoException | null) => {
if (err) {
console.error(`ఫైల్ '${accessFilePath}' చదవదగినది/వ్రాయదగినది కాదు లేదా యాక్సెస్ నిరాకరించబడింది: ${err.message}`);
return;
}
console.log(`ఫైల్ '${accessFilePath}' చదవదగినది మరియు వ్రాయదగినది.`);
});
ప్రామిస్-ఆధారిత అనుమతి తనిఖీ (`fs/promises`)
import * as fsPromises from 'fs/promises';
import { constants } from 'fs';
async function checkFilePermissions(path: string, mode: number): Promise
ఫైల్ సమాచారాన్ని పొందడం: `stat`, `statSync`, `fs.Stats`
`fs.stat` కుటుంబంలోని ఫంక్షన్‌లు ఒక ఫైల్ లేదా డైరెక్టరీ గురించి వివరణాత్మక సమాచారాన్ని అందిస్తాయి, పరిమాణం, సృష్టి తేదీ, మార్పు తేదీ మరియు అనుమతులు వంటివి. టైప్‌స్క్రిప్ట్ యొక్క `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(`'${statFilePath}' కోసం స్టాట్స్ పొందడంలో ఎర్రర్: ${err.message}`);
return;
}
console.log(`'${statFilePath}' కోసం స్టాట్స్:`);
console.log(` ఇది ఫైలా: ${stats.isFile()}`);
console.log(` ఇది డైరెక్టరీనా: ${stats.isDirectory()}`);
console.log(` పరిమాణం: ${stats.size} బైట్‌లు`);
console.log(` సృష్టి సమయం: ${stats.birthtime.toISOString()}`);
console.log(` చివరిగా మార్చబడింది: ${stats.mtime.toISOString()}`);
});
ప్రామిస్-ఆధారిత స్టాట్ (`fs/promises`)
import * as fsPromises from 'fs/promises';
import { Stats } from 'fs'; // ఇప్పటికీ 'fs' మాడ్యూల్ యొక్క Stats ఇంటర్‌ఫేస్‌ను ఉపయోగించండి
async function getFileStats(path: string): Promise
టైప్‌స్క్రిప్ట్‌తో డైరెక్టరీ ఆపరేషన్స్
ఫైళ్లను నిర్వహించడం, అప్లికేషన్-నిర్దిష్ట నిల్వను సృష్టించడం లేదా తాత్కాలిక డేటాను నిర్వహించడం కోసం డైరెక్టరీలను నిర్వహించడం ఒక సాధారణ అవసరం. టైప్‌స్క్రిప్ట్ ఈ ఆపరేషన్ల కోసం పటిష్టమైన టైపింగ్‌ను అందిస్తుంది.
డైరెక్టరీలను సృష్టించడం: `mkdir`, `mkdirSync`
`fs.mkdir` ఫంక్షన్ కొత్త డైరెక్టరీలను సృష్టించడానికి ఉపయోగించబడుతుంది. `recursive` ఆప్షన్, పేరెంట్ డైరెక్టరీలు ఉనికిలో లేకపోతే వాటిని సృష్టించడానికి చాలా ఉపయోగకరంగా ఉంటుంది, ఇది యూనిక్స్-వంటి సిస్టమ్‌లలో `mkdir -p` యొక్క ప్రవర్తనను అనుకరిస్తుంది.
అసింక్రోనస్ డైరెక్టరీ సృష్టి
import * as fs from 'fs';
const newDirPath: string = 'data/new_directory';
const recursiveDirPath: string = 'data/nested/path/to/create';
// ఒకే డైరెక్టరీని సృష్టించండి
fs.mkdir(newDirPath, (err: NodeJS.ErrnoException | null) => {
if (err) {
// డైరెక్టరీ ఇప్పటికే ఉంటే EEXIST ఎర్రర్‌ను విస్మరించండి
if (err.code === 'EEXIST') {
console.log(`డైరెక్టరీ '${newDirPath}' ఇప్పటికే ఉంది.`);
} else {
console.error(`డైరెక్టరీ '${newDirPath}' సృష్టించడంలో ఎర్రర్: ${err.message}`);
}
return;
}
console.log(`డైరెక్టరీ '${newDirPath}' విజయవంతంగా సృష్టించబడింది.`);
});
// నెస్టెడ్ డైరెక్టరీలను రికర్సివ్‌గా సృష్టించండి
fs.mkdir(recursiveDirPath, { recursive: true }, (err: NodeJS.ErrnoException | null) => {
if (err) {
if (err.code === 'EEXIST') {
console.log(`డైరెక్టరీ '${recursiveDirPath}' ఇప్పటికే ఉంది.`);
} else {
console.error(`రికర్శివ్ డైరెక్టరీ '${recursiveDirPath}' సృష్టించడంలో ఎర్రర్: ${err.message}`);
}
return;
}
console.log(`రికర్శివ్ డైరెక్టరీలు '${recursiveDirPath}' విజయవంతంగా సృష్టించబడ్డాయి.`);
});
ప్రామిస్-ఆధారిత డైరెక్టరీ సృష్టి (`fs/promises`)
import * as fsPromises from 'fs/promises';
async function createDirectory(path: string, recursive: boolean = false): Promise
డైరెక్టరీ కంటెంట్‌లను చదవడం: `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(`డైరెక్టరీ '${readDirPath}' చదవడంలో ఎర్రర్: ${err.message}`);
return;
}
console.log(`డైరెక్టరీ '${readDirPath}' యొక్క కంటెంట్‌లు:`);
files.forEach(file => {
console.log(` - ${file}`);
});
});
// `withFileTypes` ఆప్షన్‌తో
fs.readdir(readDirPath, { withFileTypes: true }, (err: NodeJS.ErrnoException | null, dirents: fs.Dirent[]) => {
if (err) {
console.error(`ఫైల్ టైప్స్‌తో డైరెక్టరీ '${readDirPath}' చదవడంలో ఎర్రర్: ${err.message}`);
return;
}
console.log(`డైరెక్టరీ '${readDirPath}' యొక్క కంటెంట్‌లు (టైప్స్‌తో):`);
dirents.forEach(dirent => {
const type: string = dirent.isFile() ? 'ఫైల్' : dirent.isDirectory() ? 'డైరెక్టరీ' : 'ఇతర';
console.log(` - ${dirent.name} (${type})`);
});
});
ప్రామిస్-ఆధారిత డైరెక్టరీ రీడ్ (`fs/promises`)
import * as fsPromises from 'fs/promises';
import { Dirent } from 'fs'; // ఇప్పటికీ 'fs' మాడ్యూల్ యొక్క Dirent ఇంటర్‌ఫేస్‌ను ఉపయోగించండి
async function listDirectoryContents(path: string): Promise
డైరెక్టరీలను తొలగించడం: `rmdir` (నిలిపివేయబడింది), `rm`, `rmSync`
నోడ్.js తన డైరెక్టరీ తొలగింపు పద్ధతులను అభివృద్ధి చేసింది. `fs.rmdir` ఇప్పుడు ఎక్కువగా `fs.rm` ద్వారా భర్తీ చేయబడింది, ఇది మరింత పటిష్టమైన మరియు స్థిరమైన APIని అందిస్తుంది.
అసింక్రోనస్ డైరెక్టరీ తొలగింపు (`fs.rm`)
`fs.rm` ఫంక్షన్ (నోడ్.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';
// సెటప్: రికర్సివ్ తొలగింపు డెమో కోసం లోపల ఒక ఫైల్‌తో డైరెక్టరీని సృష్టించండి
fs.mkdir(nestedDirToDeletePath, { recursive: true }, (err) => {
if (err && err.code !== 'EEXIST') {
console.error('డెమో కోసం నెస్టెడ్ డైరెక్టరీని సృష్టించడంలో ఎర్రర్:', err);
return;
}
fs.writeFile(`${nestedDirToDeletePath}/file_inside.txt`, 'కొంత కంటెంట్', (err) => {
if (err) { console.error('నెస్టెడ్ డైరెక్టరీ లోపల ఫైల్‌ను సృష్టించడంలో ఎర్రర్:', err); return; }
console.log(`తొలగింపు డెమో కోసం డైరెక్టరీ '${nestedDirToDeletePath}' మరియు ఫైల్ సృష్టించబడింది.`);
fs.rm(nestedDirToDeletePath, { recursive: true, force: true }, (err: NodeJS.ErrnoException | null) => {
if (err) {
console.error(`రికర్శివ్ డైరెక్టరీ '${nestedDirToDeletePath}' తొలగించడంలో ఎర్రర్: ${err.message}`);
return;
}
console.log(`రికర్శివ్ డైరెక్టరీ '${nestedDirToDeletePath}' విజయవంతంగా తొలగించబడింది.`);
});
});
});
// ఖాళీ డైరెక్టరీని తొలగించడం
fs.mkdir(dirToDeletePath, (err) => {
if (err && err.code !== 'EEXIST') {
console.error('డెమో కోసం ఖాళీ డైరెక్టరీని సృష్టించడంలో ఎర్రర్:', err);
return;
}
console.log(`తొలగింపు డెమో కోసం డైరెక్టరీ '${dirToDeletePath}' సృష్టించబడింది.`);
fs.rm(dirToDeletePath, { recursive: false }, (err: NodeJS.ErrnoException | null) => {
if (err) {
console.error(`ఖాళీ డైరెక్టరీ '${dirToDeletePath}' తొలగించడంలో ఎర్రర్: ${err.message}`);
return;
}
console.log(`ఖాళీ డైరెక్టరీ '${dirToDeletePath}' విజయవంతంగా తొలగించబడింది.`);
});
});
ప్రామిస్-ఆధారిత డైరెక్టరీ తొలగింపు (`fs/promises`)
import * as fsPromises from 'fs/promises';
async function deleteDirectory(path: string, recursive: boolean = false): Promise
టైప్‌స్క్రిప్ట్‌తో అధునాతన ఫైల్ సిస్టమ్ భావనలు
ప్రాథమిక రీడ్/రైట్ ఆపరేషన్లకు మించి, నోడ్.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
ఫైల్ స్ట్రీమ్‌లు (`fs.createReadStream`, `fs.createWriteStream`)
పెద్ద ఫైళ్లను సమర్థవంతంగా నిర్వహించడానికి స్ట్రీమ్‌లు శక్తివంతమైనవి. `fs.createReadStream` మరియు `fs.createWriteStream` వరుసగా `Readable` మరియు `Writable` స్ట్రీమ్‌లను తిరిగి ఇస్తాయి, ఇవి నోడ్.js యొక్క స్ట్రీమింగ్ APIతో సజావుగా ఏకీకృతం అవుతాయి. టైప్‌స్క్రిప్ట్ ఈ స్ట్రీమ్ ఈవెంట్‌ల కోసం (ఉదా., `'data'`, `'end'`, `'error'`) అద్భుతమైన టైప్ డెఫినిషన్‌లను అందిస్తుంది.
import * as fs from 'fs';
const largeFilePath: string = 'data/large_file.txt';
const copiedFilePath: string = 'data/copied_file.txt';
// ప్రదర్శన కోసం ఒక డమ్మీ పెద్ద ఫైల్‌ను సృష్టించండి
function createLargeFile(path: string, sizeInMB: number): void {
const content: string = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. '; // 56 అక్షరాలు
const stream = fs.createWriteStream(path);
const totalChars = sizeInMB * 1024 * 1024; // MBని బైట్‌లకు మార్చండి
const iterations = Math.ceil(totalChars / content.length);
for (let i = 0; i < iterations; i++) {
stream.write(content);
}
stream.end(() => console.log(`పెద్ద ఫైల్ '${path}' (${sizeInMB}MB) సృష్టించబడింది.`));
}
// ప్రదర్శన కోసం, మొదట 'data' డైరెక్టరీ ఉందని నిర్ధారించుకుందాం
fs.mkdir('data', { recursive: true }, (err) => {
if (err && err.code !== 'EEXIST') {
console.error('డేటా డైరెక్టరీని సృష్టించడంలో ఎర్రర్:', err);
return;
}
createLargeFile(largeFilePath, 1); // 1MB ఫైల్‌ను సృష్టించండి
});
// స్ట్రీమ్‌లను ఉపయోగించి ఫైల్‌ను కాపీ చేయండి
function copyFileWithStreams(source: string, destination: string): void {
const readStream = fs.createReadStream(source);
const writeStream = fs.createWriteStream(destination);
readStream.on('open', () => console.log(`'${source}' కోసం రీడింగ్ స్ట్రీమ్ తెరవబడింది.`));
writeStream.on('open', () => console.log(`'${destination}' కోసం రైటింగ్ స్ట్రీమ్ తెరవబడింది.`));
// రీడ్ స్ట్రీమ్ నుండి రైట్ స్ట్రీమ్‌కు డేటాను పైప్ చేయండి
readStream.pipe(writeStream);
readStream.on('error', (err: Error) => {
console.error(`రీడ్ స్ట్రీమ్ ఎర్రర్: ${err.message}`);
});
writeStream.on('error', (err: Error) => {
console.error(`రైట్ స్ట్రీమ్ ఎర్రర్: ${err.message}`);
});
writeStream.on('finish', () => {
console.log(`స్ట్రీమ్‌లను ఉపయోగించి ఫైల్ '${source}' '${destination}'కు విజయవంతంగా కాపీ చేయబడింది.`);
// కాపీ తర్వాత డమ్మీ పెద్ద ఫైల్‌ను క్లీన్ అప్ చేయండి
fs.unlink(largeFilePath, (err) => {
if (err) console.error('పెద్ద ఫైల్‌ను తొలగించడంలో ఎర్రర్:', err);
else console.log(`పెద్ద ఫైల్ '${largeFilePath}' తొలగించబడింది.`);
});
});
}
// పెద్ద ఫైల్ సృష్టించబడటానికి కొంచెం వేచి ఉండి, కాపీ చేయడానికి ప్రయత్నించండి
setTimeout(() => {
copyFileWithStreams(largeFilePath, copiedFilePath);
}, 1000);
మార్పుల కోసం గమనించడం: `fs.watch`, `fs.watchFile`
హాట్-రీలోడింగ్ డెవలప్‌మెంట్ సర్వర్లు, బిల్డ్ ప్రాసెస్‌లు లేదా రియల్-టైమ్ డేటా సింక్రొనైజేషన్ వంటి పనుల కోసం ఫైల్ సిస్టమ్‌ను మార్పుల కోసం పర్యవేక్షించడం చాలా ముఖ్యం. దీని కోసం నోడ్.js రెండు ప్రాథమిక పద్ధతులను అందిస్తుంది: `fs.watch` మరియు `fs.watchFile`. టైప్‌స్క్రిప్ట్ ఈవెంట్ రకాలు మరియు లిజనర్ పారామీటర్లు సరిగ్గా హ్యాండిల్ చేయబడతాయని నిర్ధారిస్తుంది.
`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';
// వాచింగ్ కోసం ఫైళ్లు/డైరెక్టరీలు ఉన్నాయని నిర్ధారించుకోండి
fs.writeFileSync(watchedFilePath, 'ప్రారంభ కంటెంట్.');
fs.mkdirSync(watchedDirPath, { recursive: true });
console.log(`మార్పుల కోసం '${watchedFilePath}' గమనించబడుతోంది...`);
const fileWatcher = fs.watch(watchedFilePath, (eventType: string, filename: string | Buffer | null) => {
const fname = typeof filename === 'string' ? filename : filename?.toString('utf8');
console.log(`ఫైల్ '${fname || 'N/A'}' ఈవెంట్: ${eventType}`);
if (eventType === 'change') {
console.log('ఫైల్ కంటెంట్ బహుశా మార్చబడింది.');
}
// నిజమైన అప్లికేషన్‌లో, మీరు ఇక్కడ ఫైల్‌ను చదవవచ్చు లేదా రీబిల్డ్‌ను ట్రిగ్గర్ చేయవచ్చు
});
console.log(`మార్పుల కోసం డైరెక్టరీ '${watchedDirPath}' గమనించబడుతోంది...`);
const dirWatcher = fs.watch(watchedDirPath, (eventType: string, filename: string | Buffer | null) => {
const fname = typeof filename === 'string' ? filename : filename?.toString('utf8');
console.log(`డైరెక్టరీ '${watchedDirPath}' ఈవెంట్: ${eventType} '${fname || 'N/A'}'పై`);
});
fileWatcher.on('error', (err: Error) => console.error(`ఫైల్ వాచర్ ఎర్రర్: ${err.message}`));
dirWatcher.on('error', (err: Error) => console.error(`డైరెక్టరీ వాచర్ ఎర్రర్: ${err.message}`));
// ఆలస్యం తర్వాత మార్పులను అనుకరించండి
setTimeout(() => {
console.log('\n--- మార్పులను అనుకరిస్తోంది ---');
fs.appendFileSync(watchedFilePath, '\nకొత్త లైన్ జోడించబడింది.');
fs.writeFileSync(`${watchedDirPath}/new_file.txt`, 'కంటెంట్.');
fs.unlinkSync(`${watchedDirPath}/new_file.txt`); // తొలగింపును కూడా పరీక్షించండి
setTimeout(() => {
fileWatcher.close();
dirWatcher.close();
console.log('\nవాచర్లు మూసివేయబడ్డాయి.');
// తాత్కాలిక ఫైళ్లు/డైరెక్టరీలను క్లీన్ అప్ చేయండి
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, 'ప్రారంభ పోల్డ్ కంటెంట్.');
console.log(`మార్పుల కోసం '${pollFilePath}' పోలింగ్ చేయబడుతోంది...`);
fs.watchFile(pollFilePath, { interval: 1000 }, (curr: Stats, prev: Stats) => {
// టైప్‌స్క్రిప్ట్ 'curr' మరియు 'prev' fs.Stats ఆబ్జెక్ట్‌లు అని నిర్ధారిస్తుంది
if (curr.mtimeMs !== prev.mtimeMs) {
console.log(`ఫైల్ '${pollFilePath}' మార్చబడింది (mtime మారింది). కొత్త పరిమాణం: ${curr.size} బైట్‌లు.`);
}
});
setTimeout(() => {
console.log('\n--- పోల్డ్ ఫైల్ మార్పును అనుకరిస్తోంది ---');
fs.appendFileSync(pollFilePath, '\nపోల్డ్ ఫైల్‌కు మరో లైన్ జోడించబడింది.');
setTimeout(() => {
fs.unwatchFile(pollFilePath);
console.log(`\n'${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');
// సింక్రోనస్ ఎర్రర్ హ్యాండ్లింగ్
try {
fs.readFileSync(problematicPath, 'utf8');
} catch (error: any) {
console.error(`సింక్ ఎర్రర్: ${error.code} - ${error.message} (పాత్: ${problematicPath})`);
}
// కాల్‌బ్యాక్-ఆధారిత ఎర్రర్ హ్యాండ్లింగ్
fs.readFile(problematicPath, 'utf8', (err, data) => {
if (err) {
console.error(`కాల్‌బ్యాక్ ఎర్రర్: ${err.code} - ${err.message} (పాత్: ${problematicPath})`);
return;
}
// ... డేటాను ప్రాసెస్ చేయండి
});
// ప్రామిస్-ఆధారిత ఎర్రర్ హ్యాండ్లింగ్
async function safeReadFile(filePath: string): Promise
వనరుల నిర్వహణ: ఫైల్ డిస్క్రిప్టర్‌లను మూసివేయడం
`fs.open` (లేదా `fsPromises.open`)తో పనిచేసేటప్పుడు, ఆపరేషన్‌లు పూర్తయిన తర్వాత, ఎర్రర్‌లు సంభవించినప్పటికీ, ఫైల్ డిస్క్రిప్టర్లు ఎల్లప్పుడూ `fs.close` (లేదా `fileHandle.close()`) ఉపయోగించి మూసివేయబడతాయని నిర్ధారించుకోవడం చాలా ముఖ్యం. అలా చేయడంలో విఫలమైతే వనరుల లీక్‌లకు, ఆపరేటింగ్ సిస్టమ్ యొక్క ఓపెన్ ఫైల్ పరిమితిని చేరుకోవడానికి మరియు మీ అప్లికేషన్‌ను క్రాష్ చేయడానికి లేదా ఇతర ప్రాసెస్‌లను ప్రభావితం చేయడానికి దారితీయవచ్చు.
`FileHandle` ఆబ్జెక్ట్‌లతో కూడిన `fs/promises` API సాధారణంగా దీనిని సులభతరం చేస్తుంది, ఎందుకంటే `fileHandle.close()` ప్రత్యేకంగా ఈ ప్రయోజనం కోసం రూపొందించబడింది, మరియు `FileHandle` ఇన్‌స్టాన్స్‌లు `Disposable` (నోడ్.js 18.11.0+ మరియు టైప్‌స్క్రిప్ట్ 5.2+ ఉపయోగిస్తుంటే).
పాత్ మేనేజ్‌మెంట్ మరియు క్రాస్-ప్లాట్‌ఫారమ్ అనుకూలత
ఫైల్ పాత్‌లు ఆపరేటింగ్ సిస్టమ్‌ల మధ్య గణనీయంగా మారుతూ ఉంటాయి (ఉదా., విండోస్‌లో `\`, యూనిక్స్-వంటి సిస్టమ్‌లలో `/`). గ్లోబల్ డిప్లాయ్‌మెంట్ల కోసం అవసరమైన క్రాస్-ప్లాట్‌ఫారమ్ అనుకూలమైన మార్గంలో ఫైల్ పాత్‌లను నిర్మించడానికి మరియు పార్స్ చేయడానికి నోడ్.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';
// క్రాస్-ప్లాట్‌ఫారమ్ పాత్ జాయినింగ్
const fullPath: string = path.join(__dirname, dir, filename);
console.log(`క్రాస్-ప్లాట్‌ఫారమ్ పాత్: ${fullPath}`);
// డైరెక్టరీ పేరును పొందండి
const dirname: string = path.dirname(fullPath);
console.log(`డైరెక్టరీ పేరు: ${dirname}`);
// బేస్ ఫైల్ పేరును పొందండి
const basename: string = path.basename(fullPath);
console.log(`బేస్ పేరు: ${basename}`);
// ఫైల్ పొడిగింపును పొందండి
const extname: string = path.extname(fullPath);
console.log(`పొడిగింపు: ${extname}`);
ఏకకాలీనత మరియు రేస్ కండిషన్స్
బహుళ అసింక్రోనస్ ఫైల్ ఆపరేషన్‌లు ఏకకాలంలో ప్రారంభించబడినప్పుడు, ముఖ్యంగా రైట్స్ లేదా డిలీషన్స్, రేస్ కండిషన్స్ సంభవించవచ్చు. ఉదాహరణకు, ఒక ఆపరేషన్ ఒక ఫైల్ ఉనికిని తనిఖీ చేసి, మొదటి ఆపరేషన్ పనిచేయడానికి ముందే మరొకటి దాన్ని తొలగిస్తే, మొదటి ఆపరేషన్ ఊహించని విధంగా విఫలం కావచ్చు.
- క్లిష్టమైన పాత్ లాజిక్ కోసం `fs.existsSync`ను నివారించండి; `fs.access`ను ఇష్టపడండి లేదా కేవలం ఆపరేషన్‌ను ప్రయత్నించి ఎర్రర్‌ను హ్యాండిల్ చేయండి.
- ప్రత్యేక యాక్సెస్ అవసరమైన ఆపరేషన్ల కోసం, తగిన `flag` ఆప్షన్‌లను (ఉదా., ప్రత్యేక రైట్ కోసం `'wx'`) ఉపయోగించండి.
- అత్యంత క్లిష్టమైన షేర్డ్ రిసోర్స్ యాక్సెస్ కోసం లాకింగ్ మెకానిజమ్‌లను (ఉదా., ఫైల్ లాక్‌లు, లేదా అప్లికేషన్-స్థాయి లాక్‌లు) అమలు చేయండి, అయితే ఇది సంక్లిష్టతను జోడిస్తుంది.
అనుమతులు (ACLs)
ఫైల్ సిస్టమ్ అనుమతులు (యాక్సెస్ కంట్రోల్ లిస్ట్‌లు లేదా ప్రామాణిక యూనిక్స్ అనుమతులు) ఎర్రర్‌లకు ఒక సాధారణ మూలం. మీ నోడ్.js ప్రాసెస్‌కు ఫైళ్లు మరియు డైరెక్టరీలను చదవడానికి, వ్రాయడానికి లేదా అమలు చేయడానికి అవసరమైన అనుమతులు ఉన్నాయని నిర్ధారించుకోండి. ఇది కంటైనరైజ్డ్ వాతావరణాలలో లేదా ప్రాసెస్‌లు నిర్దిష్ట వినియోగదారు ఖాతాలతో నడిచే బహుళ-వినియోగదారు సిస్టమ్‌లలో ప్రత్యేకంగా సంబంధితంగా ఉంటుంది.
ముగింపు: గ్లోబల్ ఫైల్ సిస్టమ్ ఆపరేషన్ల కోసం టైప్ సేఫ్టీని స్వీకరించడం
నోడ్.js `fs` మాడ్యూల్ ఫైల్ సిస్టమ్‌తో ఇంటరాక్ట్ అవ్వడానికి ఒక శక్తివంతమైన మరియు బహుముఖ సాధనం, ఇది ప్రాథమిక ఫైల్ మానిప్యులేషన్‌ల నుండి అధునాతన స్ట్రీమ్-ఆధారిత డేటా ప్రాసెసింగ్ వరకు అనేక ఎంపికలను అందిస్తుంది. ఈ ఆపరేషన్‌లపై టైప్‌స్క్రిప్ట్‌ను పొరగా వేయడం ద్వారా, మీరు అమూల్యమైన ప్రయోజనాలను పొందుతారు: కంపైల్-టైమ్ ఎర్రర్ డిటెక్షన్, మెరుగైన కోడ్ స్పష్టత, ఉన్నతమైన టూలింగ్ మద్దతు మరియు రిఫ్యాక్టరింగ్ సమయంలో పెరిగిన విశ్వాసం. ఇది ప్రత్యేకించి గ్లోబల్ డెవలప్‌మెంట్ బృందాలకు చాలా ముఖ్యం, ఇక్కడ విభిన్న కోడ్‌బేస్‌లలో స్థిరత్వం మరియు తగ్గిన అస్పష్టత చాలా ముఖ్యమైనవి.
మీరు ఒక చిన్న యుటిలిటీ స్క్రిప్ట్ లేదా ఒక పెద్ద-స్థాయి ఎంటర్‌ప్రైజ్ అప్లికేషన్‌ను నిర్మిస్తున్నా, మీ నోడ్.js ఫైల్ ఆపరేషన్ల కోసం టైప్‌స్క్రిప్ట్ యొక్క పటిష్టమైన టైప్ సిస్టమ్‌ను ఉపయోగించడం మరింత నిర్వహించదగిన, విశ్వసనీయమైన మరియు ఎర్రర్-నిరోధక కోడ్‌కు దారితీస్తుంది. క్లీనర్ అసింక్రోనస్ పద్ధతుల కోసం `fs/promises` APIని స్వీకరించండి, సింక్రోనస్ మరియు అసింక్రోనస్ కాల్స్ మధ్య సూక్ష్మ నైపుణ్యాలను అర్థం చేసుకోండి, మరియు ఎల్లప్పుడూ పటిష్టమైన ఎర్రర్ హ్యాండ్లింగ్ మరియు క్రాస్-ప్లాట్‌ఫారమ్ పాత్ మేనేజ్‌మెంట్‌కు ప్రాధాన్యత ఇవ్వండి.
ఈ గైడ్‌లో చర్చించిన సూత్రాలు మరియు ఉదాహరణలను వర్తింపజేయడం ద్వారా, ప్రపంచవ్యాప్తంగా ఉన్న డెవలపర్‌లు ఫైల్ సిస్టమ్ ఇంటరాక్షన్‌లను నిర్మించగలరు, అవి కేవలం పనితీరు మరియు సమర్థవంతమైనవి మాత్రమే కాకుండా, స్వాభావికంగా మరింత సురక్షితమైనవి మరియు అర్థం చేసుకోవడానికి సులభమైనవి, చివరికి అధిక నాణ్యత గల సాఫ్ట్‌వేర్ డెలివరబుల్స్‌కు దోహదం చేస్తాయి.