ટાઈપસ્ક્રીપ્ટ ફાઈલ સિસ્ટમ નિપુણતા: વૈશ્વિક ડેવલપર્સ માટે ટાઈપ સેફ્ટી સાથે Node.js ફાઈલ ઓપરેશન્સ

આધુનિક સોફ્ટવેર ડેવલપમેન્ટના વિશાળ લેન્ડસ્કેપમાં, Node.js સ્કેલેબલ સર્વર-સાઇડ એપ્લિકેશન્સ, કમાન્ડ-લાઈન ટૂલ્સ અને વધુ બનાવવા માટે શક્તિશાળી રનટાઇમ તરીકે ઊભું છે. ઘણી Node.js એપ્લિકેશન્સનું એક મૂળભૂત પાસું ફાઇલ સિસ્ટમ સાથે ક્રિયાપ્રતિક્રિયા કરવાનો છે – ફાઇલો અને ડિરેક્ટરીઓ વાંચવા, લખવા, બનાવવા અને મેનેજ કરવા. જ્યારે જાવાસ્ક્રિપ્ટ આ ઑપરેશન્સને હેન્ડલ કરવા માટે ફ્લેક્સિબિલિટી પ્રદાન કરે છે, ત્યારે ટાઈપસ્ક્રીપ્ટનો પરિચય સ્ટેટિક ટાઈપ-ચેકિંગ, સુધારેલા ટૂલિંગ અને અંતે, તમારી ફાઈલ સિસ્ટમ કોડમાં વધુ વિશ્વસનીયતા અને જાળવણીક્ષમતા લાવીને આ અનુભવને ઉત્તેજીત કરે છે.

આ વ્યાપક માર્ગદર્શિકા ડેવલપર્સના વૈશ્વિક પ્રેક્ષકો માટે બનાવવામાં આવી છે, તેમની સાંસ્કૃતિક પૃષ્ઠભૂમિ અથવા ભૌગોલિક સ્થાનને ધ્યાનમાં લીધા વિના, જેઓ ટાઈપસ્ક્રીપ્ટ દ્વારા ઓફર કરાયેલ મજબૂતાઈ સાથે Node.js ફાઈલ ઑપરેશન્સમાં નિપુણતા મેળવવા માંગે છે. અમે મુખ્ય `fs` મોડ્યુલમાં ઊંડાણપૂર્વક જઈશું, તેના વિવિધ સિંક્રોનસ અને અસિંક્રોનસ પેરાડાઈમ્સનું અન્વેષણ કરીશું, આધુનિક પ્રોમિસ-આધારિત API નું પરીક્ષણ કરીશું, અને ટાઈપસ્ક્રીપ્ટની ટાઈપ સિસ્ટમ સામાન્ય ભૂલોને કેવી રીતે નોંધપાત્ર રીતે ઘટાડી શકે છે અને તમારા કોડની સ્પષ્ટતામાં સુધારો કરી શકે છે તે શોધીશું.

પાયાનો પથ્થર: Node.js ફાઈલ સિસ્ટમ (`fs`) ને સમજવું

Node.js `fs` મોડ્યુલ ફાઈલ સિસ્ટમ સાથે POSIX સ્ટાન્ડર્ડ ફંક્શન્સ પર આધારિત રીતે ક્રિયાપ્રતિક્રિયા કરવા માટે API પ્રદાન કરે છે. તે મૂળભૂત ફાઈલ વાંચન અને લેખનથી લઈને જટિલ ડિરેક્ટરી મેનિપ્યુલેશન્સ અને ફાઈલ વોચિંગ સુધીની પદ્ધતિઓની વિશાળ શ્રેણી પ્રદાન કરે છે. પરંપરાગત રીતે, આ ઑપરેશન્સ કૉલબૅક્સ સાથે હેન્ડલ કરવામાં આવતા હતા, જેના કારણે જટિલ પરિસ્થિતિઓમાં કુખ્યાત "કૉલબૅક હેલ" થતું હતું. Node.js ના વિકાસ સાથે, પ્રોમિસિસ અને `async/await` અસિંક્રોનસ ઑપરેશન્સ માટે પસંદગીના પેટર્ન તરીકે ઉભરી આવ્યા છે, જે કોડને વધુ વાંચવા યોગ્ય અને વ્યવસ્થાપિત બનાવે છે.

ફાઈલ સિસ્ટમ ઑપરેશન્સ માટે ટાઈપસ્ક્રીપ્ટ શા માટે?

જ્યારે Node.js નું `fs` મોડ્યુલ સાદા જાવાસ્ક્રિપ્ટ સાથે સંપૂર્ણ રીતે કાર્ય કરે છે, ત્યારે ટાઈપસ્ક્રીપ્ટને એકીકૃત કરવાથી કેટલાક આકર્ષક ફાયદાઓ મળે છે:

• ટાઈપ સેફ્ટી: તમારા કોડ ચાલતા પહેલા, કમ્પાઈલ ટાઈમ પર ખોટા આર્ગ્યુમેન્ટ ટાઈપ્સ, ગુમ થયેલા પેરામીટર્સ અથવા અણધારી રિટર્ન વેલ્યુ જેવી સામાન્ય ભૂલો પકડી પાડે છે. આ અત્યંત મૂલ્યવાન છે, ખાસ કરીને જ્યારે વિવિધ ફાઈલ એન્કોડિંગ્સ, ફ્લેગ્સ અને `Buffer` ઑબ્જેક્ટ્સ સાથે કામ કરતા હોય.
• વધારેલી વાંચનક્ષમતા: સ્પષ્ટ ટાઈપ એનોટેશન્સ સ્પષ્ટ કરે છે કે ફંક્શન કયા પ્રકારનો ડેટા અપેક્ષા રાખે છે અને તે શું રિટર્ન કરશે, જે વિવિધ ટીમોમાં ડેવલપર્સ માટે કોડની સમજણને સુધારે છે.
• બહેતર ટૂલિંગ અને ઑટોકમ્પલીશન: IDEs (જેમ કે VS કોડ) ટાઈપસ્ક્રીપ્ટની ટાઈપ ડેફિનેશન્સનો લાભ લઈને ઇન્ટેલિજન્ટ ઑટોકમ્પલીશન, પેરામીટર હિન્ટ્સ અને ઇનલાઇન ડોક્યુમેન્ટેશન પ્રદાન કરે છે, જે ઉત્પાદકતાને નોંધપાત્ર રીતે વેગ આપે છે.
• રીફેક્ટરિંગ આત્મવિશ્વાસ: જ્યારે તમે ઇન્ટરફેસ અથવા ફંક્શન સિગ્નેચર બદલો છો, ત્યારે ટાઈપસ્ક્રીપ્ટ તરત જ તમામ અસરગ્રસ્ત વિસ્તારોને ફ્લેગ કરે છે, જેનાથી મોટા પાયે રીફેક્ટરિંગ ઓછું ભૂલ-પ્રવણ બને છે.
• વૈશ્વિક સુસંગતતા: આંતરરાષ્ટ્રીય ડેવલપમેન્ટ ટીમોમાં સુસંગત કોડિંગ શૈલી અને ડેટા સ્ટ્રક્ચર્સની સમજણ સુનિશ્ચિત કરે છે, જેનાથી અસ્પષ્ટતા ઓછી થાય છે.

સિંક્રોનસ વિ. અસિંક્રોનસ ઑપરેશન્સ: વૈશ્વિક પરિપ્રેક્ષ્ય

સિંક્રોનસ અને અસિંક્રોનસ ઑપરેશન્સ વચ્ચેનો ભેદ સમજવો અત્યંત મહત્વપૂર્ણ છે, ખાસ કરીને જ્યારે વૈશ્વિક ડિપ્લોયમેન્ટ માટે એપ્લિકેશન્સ બનાવતા હોય ત્યારે જ્યાં પર્ફોર્મન્સ અને રિસ્પોન્સિવનેસ સર્વોપરી હોય છે. મોટાભાગના `fs` મોડ્યુલ ફંક્શન્સ સિંક્રોનસ અને અસિંક્રોનસ સ્વરૂપોમાં આવે છે. એક સામાન્ય નિયમ તરીકે, નોન-બ્લૉકિંગ I/O ઑપરેશન્સ માટે અસિંક્રોનસ પદ્ધતિઓ પસંદ કરવામાં આવે છે, જે તમારા Node.js સર્વરની રિસ્પોન્સિવનેસ જાળવવા માટે આવશ્યક છે.

• અસિંક્રોનસ (નોન-બ્લૉકિંગ): આ પદ્ધતિઓ તેમના છેલ્લા આર્ગ્યુમેન્ટ તરીકે કૉલબૅક ફંક્શન લે છે અથવા `Promise` રિટર્ન કરે છે. તેઓ ફાઈલ સિસ્ટમ ઑપરેશન શરૂ કરે છે અને તરત જ રિટર્ન થાય છે, જેનાથી અન્ય કોડ એક્ઝિક્યુટ થઈ શકે છે. જ્યારે ઑપરેશન પૂર્ણ થાય છે, ત્યારે કૉલબૅક ઇન્વોક થાય છે (અથવા પ્રોમિસ રિઝોલ્વ/રિજેક્ટ થાય છે). આ વિશ્વભરના વપરાશકર્તાઓ પાસેથી બહુવિધ કન્કરન્ટ વિનંતીઓને હેન્ડલ કરતી સર્વર એપ્લિકેશન્સ માટે આદર્શ છે, કારણ કે તે ફાઈલ ઑપરેશન પૂર્ણ થવાની રાહ જોતી વખતે સર્વરને થીજવાથી અટકાવે છે.
• સિંક્રોનસ (બ્લૉકિંગ): આ પદ્ધતિઓ રિટર્ન કરતા પહેલા ઑપરેશનને સંપૂર્ણપણે પરફોર્મ કરે છે. કોડ કરવું સરળ હોવા છતાં, તેઓ Node.js ઇવેન્ટ લૂપને બ્લૉક કરે છે, ફાઈલ સિસ્ટમ ઑપરેશન પૂર્ણ ન થાય ત્યાં સુધી અન્ય કોઈપણ કોડને ચાલતા અટકાવે છે. આ નોંધપાત્ર પર્ફોર્મન્સ બોટલનેક્સ અને રિસ્પોન્સિવ ન હોય તેવી એપ્લિકેશન્સ તરફ દોરી શકે છે, ખાસ કરીને ઉચ્ચ-ટ્રાફિક વાતાવરણમાં. તેનો ઓછો ઉપયોગ કરો, ખાસ કરીને એપ્લિકેશન સ્ટાર્ટઅપ લૉજિક અથવા સરળ સ્ક્રિપ્ટો માટે જ્યાં બ્લૉકિંગ સ્વીકાર્ય હોય.

ટાઈપસ્ક્રીપ્ટમાં મુખ્ય ફાઈલ ઑપરેશન ટાઈપ્સ

ચાલો સામાન્ય ફાઈલ સિસ્ટમ ઑપરેશન્સ સાથે ટાઈપસ્ક્રીપ્ટના વ્યવહારિક ઉપયોગમાં ઊંડાણપૂર્વક જઈએ. અમે 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

ફાઈલોમાંથી કન્ટેન્ટ વાંચવું એ એક મૂળભૂત ઑપરેશન છે. ટાઈપસ્ક્રીપ્ટ તમને ફાઈલ પાથ, એન્કોડિંગ્સ અને સંભવિત ભૂલોને યોગ્ય રીતે હેન્ડલ કરવામાં મદદ કરે છે.

અસિંક્રોનસ ફાઈલ રીડ (કૉલબૅક-આધારિત)

The `fs.readFile` function is the workhorse for asynchronous file reading. It takes the path, an optional encoding, and a callback function. TypeScript ensures the callback's arguments are correctly typed (`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`, અને ફ્લેગ્સ

ફાઈલોમાં ડેટા લખવો પણ એટલો જ મહત્વપૂર્ણ છે. ટાઈપસ્ક્રીપ્ટ ફાઈલ પાથ, ડેટા ટાઈપ્સ (સ્ટ્રિંગ અથવા બફર), એન્કોડિંગ અને ફાઈલ ઓપન ફ્લેગ્સનું સંચાલન કરવામાં મદદ કરે છે.

અસિંક્રોનસ ફાઈલ રાઈટ

`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`

ફાઈલ સિસ્ટમમાંથી ફાઈલો દૂર કરવી. ટાઈપસ્ક્રીપ્ટ તમને માન્ય પાથ પાસ કરવામાં અને ભૂલોને યોગ્ય રીતે હેન્ડલ કરવામાં મદદ કરે છે.

અસિંક્રોનસ ડિલીટ

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

The `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(`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

ટાઈપસ્ક્રીપ્ટ સાથે ડિરેક્ટરી ઑપરેશન્સ

ફાઈલોને વ્યવસ્થિત કરવા, એપ્લિકેશન-વિશિષ્ટ સ્ટોરેજ બનાવવા અથવા કામચલાઉ ડેટાને હેન્ડલ કરવા માટે ડિરેક્ટરીઓનું સંચાલન કરવું એક સામાન્ય જરૂરિયાત છે. ટાઈપસ્ક્રીપ્ટ આ ઑપરેશન્સ માટે મજબૂત ટાઈપિંગ પ્રદાન કરે છે.

ડિરેક્ટરીઓ બનાવવી: `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 * 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 })();

ટાઈપસ્ક્રીપ્ટ સાથે એડવાન્સ્ડ ફાઈલ સિસ્ટમ કોન્સેપ્ટ્સ

મૂળભૂત રીડ/રાઈટ ઑપરેશન્સ ઉપરાંત, 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 *s 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 *s 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 *s 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 એરર, નેટવર્ક સમસ્યાઓ (નેટવર્ક-માઉન્ટેડ ડ્રાઈવ માટે), અથવા કન્કરન્ટ ઍક્સેસ વિરોધાભાસ. ટાઈપસ્ક્રીપ્ટ તમને ટાઈપ-સંબંધિત સમસ્યાઓને પકડવામાં મદદ કરે છે, પરંતુ રનટાઈમ એરર્સને હજુ પણ કાળજીપૂર્વક સંચાલિત કરવાની જરૂર છે.

એરર હેન્ડલિંગ સ્ટ્રેટેજીસ

• સિંક્રોનસ ઑપરેશન્સ: હંમેશા `try...catch` બ્લોક્સમાં `fs.xxxSync` કૉલ્સને લપેટો. આ પદ્ધતિઓ સીધા જ એરર્સ ફેંકે છે.
• અસિંક્રોનસ કૉલબૅક્સ: `fs` કૉલબૅકનું પ્રથમ આર્ગ્યુમેન્ટ હંમેશા `err: NodeJS.ErrnoException | null` હોય છે. હંમેશા પહેલા આ `err` ઑબ્જેક્ટ માટે તપાસ કરો.
• પ્રોમિસ-આધારિત (`fs/promises`): રિજેક્શન્સને હેન્ડલ કરવા માટે `await` સાથે `try...catch` અથવા `.then()` ચેન સાથે `.catch()` નો ઉપયોગ કરો.

જો તમારી એપ્લિકેશનનો એરર ફીડબેક યુઝર-ફેસિંગ હોય તો એરર લોગિંગ ફોર્મેટને સ્ટાન્ડર્ડાઈઝ કરવું અને એરર મેસેજ માટે ઇન્ટરનેશનલાઇઝેશન (i18n) ધ્યાનમાં લેવું ફાયદાકારક છે.

import *s fs from 'fs'; import { promises as fsPromises } from 'fs'; import *s 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()`) નો ઉપયોગ કરીને બંધ કરવામાં આવે. આમ કરવામાં નિષ્ફળતા રિસોર્સ લીક્સ, ઓપરેટિંગ સિસ્ટમની ઓપન ફાઈલ લિમિટ સુધી પહોંચવા અને સંભવતઃ તમારી એપ્લિકેશનને ક્રેશ કરવા અથવા અન્ય પ્રક્રિયાઓને અસર કરવા તરફ દોરી શકે છે.

The `fs/promises` API with `FileHandle` ઑબ્જેક્ટ્સ સામાન્ય રીતે આને સરળ બનાવે છે, કારણ કે `fileHandle.close()` ખાસ કરીને આ હેતુ માટે રચાયેલ છે, અને `FileHandle` ઇન્સ્ટન્સ `Disposable` છે (જો Node.js 18.11.0+ અને ટાઈપસ્ક્રીપ્ટ 5.2+ નો ઉપયોગ કરતા હોય તો).

પાથ મેનેજમેન્ટ અને ક્રોસ-પ્લેટફોર્મ સુસંગતતા

ઓપરેટિંગ સિસ્ટમ્સ (દા.ત., Windows પર `\\`, Unix-જેવી સિસ્ટમ્સ પર `/`) વચ્ચે ફાઈલ પાથ નોંધપાત્ર રીતે બદલાય છે. The Node.js `path` મોડ્યુલ ક્રોસ-પ્લેટફોર્મ સુસંગત રીતે ફાઈલ પાથ બનાવવા અને પાર્સ કરવા માટે અનિવાર્ય છે, જે વૈશ્વિક ડિપ્લોયમેન્ટ માટે આવશ્યક છે.

• `path.join(...paths)`: આપેલ તમામ પાથ સેગમેન્ટ્સને એકસાથે જોડે છે, પરિણામી પાથને સામાન્ય બનાવે છે.
• `path.resolve(...paths)`: પાથ અથવા પાથ સેગમેન્ટ્સના ક્રમને સંપૂર્ણ પાથમાં રિઝોલ્વ કરે છે.
• `path.basename(path)`: પાથનો છેલ્લો ભાગ રિટર્ન કરે છે.
• `path.dirname(path)`: પાથનું ડિરેક્ટરી નામ રિટર્ન કરે છે.
• `path.extname(path)`: પાથનું એક્સટેન્શન રિટર્ન કરે છે.

TypeScript provides full type definitions for the `path` મોડ્યુલ, ensuring you use its functions correctly.

import *s 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'` for exclusive write).
• અત્યંત જટિલ શેર કરેલ રિસોર્સ ઍક્સેસ માટે લૉકિંગ મિકેનિઝમ્સ (દા.ત., ફાઈલ લૉક્સ, અથવા એપ્લિકેશન-લેવલ લૉક્સ) અમલમાં મૂકો, જોકે આ જટિલતા ઉમેરે છે.

પરવાનગીઓ (ACLs)

ફાઈલ સિસ્ટમ પરવાનગીઓ (એક્સેસ કંટ્રોલ લિસ્ટ્સ અથવા સ્ટાન્ડર્ડ Unix પરવાનગીઓ) ભૂલોનો એક સામાન્ય સ્ત્રોત છે. ખાતરી કરો કે તમારી Node.js પ્રક્રિયામાં ફાઈલો અને ડિરેક્ટરીઓને વાંચવા, લખવા અથવા એક્ઝિક્યુટ કરવા માટે જરૂરી પરવાનગીઓ છે. આ ખાસ કરીને કન્ટેનરાઇઝ્ડ વાતાવરણમાં અથવા મલ્ટિ-યુઝર સિસ્ટમ્સ પર સુસંગત છે જ્યાં પ્રક્રિયાઓ ચોક્કસ યુઝર એકાઉન્ટ્સ સાથે ચાલે છે.

નિષ્કર્ષ: વૈશ્વિક ફાઈલ સિસ્ટમ ઑપરેશન્સ માટે ટાઈપ સેફ્ટી અપનાવવી

Node.js `fs` મોડ્યુલ ફાઈલ સિસ્ટમ સાથે ક્રિયાપ્રતિક્રિયા કરવા માટે એક શક્તિશાળી અને બહુમુખી સાધન છે, જે મૂળભૂત ફાઈલ મેનિપ્યુલેશન્સથી લઈને એડવાન્સ્ડ સ્ટ્રીમ-આધારિત ડેટા પ્રોસેસિંગ સુધીના વિકલ્પો પ્રદાન કરે છે. આ ઑપરેશન્સ પર ટાઈપસ્ક્રીપ્ટનું લેયરિંગ કરીને, તમે અમૂલ્ય લાભો મેળવો છો: કમ્પાઈલ-ટાઈમ એરર ડિટેક્શન, વધેલી કોડ સ્પષ્ટતા, શ્રેષ્ઠ ટૂલિંગ સપોર્ટ અને રીફેક્ટરિંગ દરમિયાન વધેલો આત્મવિશ્વાસ. આ ખાસ કરીને વૈશ્વિક ડેવલપમેન્ટ ટીમો માટે નિર્ણાયક છે જ્યાં વિવિધ કોડબેસમાં સુસંગતતા અને ઓછી અસ્પષ્ટતા મહત્વપૂર્ણ છે.

તમે એક નાની યુટિલિટી સ્ક્રિપ્ટ બનાવી રહ્યા હોવ કે મોટા પાયે એન્ટરપ્રાઈઝ એપ્લિકેશન, તમારી Node.js ફાઈલ ઑપરેશન્સ માટે ટાઈપસ્ક્રીપ્ટના મજબૂત ટાઈપ સિસ્ટમનો લાભ લેવાથી વધુ જાળવવા યોગ્ય, વિશ્વસનીય અને ભૂલ-પ્રતિરોધક કોડ બનશે. સ્વચ્છ અસિંક્રોનસ પેટર્ન માટે `fs/promises` API ને અપનાવો, સિંક્રોનસ અને અસિંક્રોનસ કૉલ્સ વચ્ચેના સૂક્ષ્મ તફાવતોને સમજો, અને હંમેશા મજબૂત એરર હેન્ડલિંગ અને ક્રોસ-પ્લેટફોર્મ પાથ મેનેજમેન્ટને પ્રાધાન્ય આપો.

આ માર્ગદર્શિકામાં ચર્ચા કરાયેલા સિદ્ધાંતો અને ઉદાહરણોનો ઉપયોગ કરીને, વિશ્વભરના ડેવલપર્સ ફાઈલ સિસ્ટમ ઇન્ટરેક્શન્સ બનાવી શકે છે જે માત્ર પર્ફોર્મન્ટ અને કાર્યક્ષમ જ નથી પણ સ્વાભાવિક રીતે વધુ સુરક્ષિત અને સમજવામાં સરળ પણ છે, જે આખરે ઉચ્ચ ગુણવત્તાવાળા સોફ્ટવેર ડિલિવરેબલ્સમાં ફાળો આપે છે.