તમે Node માં ફાઇલ સિસ્ટમ સાથે કેવી રીતે કામ કરો છો?

Question

Accepted Answer

બિલ્ટ-ઇન **`fs`** મોડ્યુલ ફાઇલો અને ડિરેક્ટરીઓ વાંચે છે અને લખે છે. તે ત્રણ API શૈલીઓ પ્રદાન કરે છે — **promises** (આધુનિક, પસંદ), **callbacks** (મૂળ async), અને **sync** (અવરોધક) — તેથી તમે પરિસ્થિતિ માટે યોગ્ય પસંદ કરી શકો.

## Promise API (ભલામણ)

```js
import { readFile, writeFile, mkdir, readdir } from "fs/promises";

async function work() {
  const data = await readFile("input.txt", "utf8");     // read (utf8 → string)
  await writeFile("output.txt", "Hello");                // write (overwrites)
  await mkdir("new-dir", { recursive: true });           // create dirs (recursive = mkdir -p)
  const files = await readdir("./");                      // list directory contents
}
```

`fs/promises` API async/await સાથે સ્વચ્છતાથી કામ કરે છે — ફાઇલ I/O માટે આધુનિક ડિફૉલ્ટ.

## Callback અને sync વેરિયન્ટ્સ

```js
import fs from "fs";

fs.readFile("file.txt", "utf8", (err, data) => { ... }); // async callback
const data = fs.readFileSync("file.txt", "utf8");         // SYNC — blocks the event loop!
```

**સાવધાન:** `*Sync` પદ્ધતિઓ **સમગ્ર ઇવેન્ટ લૂપને અવરોધિત કરે છે** જ્યાં સુધી ઓપરેશન સમાપ્ત ન થાય. તેઓ સ્ટાર્ટআપ પર ઠીક છે (કોન્ફિગ એક વાર લોડ કરવું) પરંતુ વિનંતી હ్యાન્ડલર્સમાં તેમને ટાળવું જોઈએ — અવરોધક વાંચન તમામ સમવર્તી વિનંતીઓને સ્થિર કરે છે.

## સામાન્ય કામગીરી

```js
await fs.promises.appendFile("log.txt", "new line
"); // append
await fs.promises.unlink("old.txt");                    // delete a file
await fs.promises.rename("a.txt", "b.txt");             // rename/move
const stats = await fs.promises.stat("file.txt");       // metadata (size, mtime)
const exists = fs.existsSync("file.txt");               // check existence
```

## મોટી ફાઇલો માટે: streams વાપરો

```js
// ❌ readFile loads the WHOLE file into memory — bad for huge files
const huge = await readFile("10gb.txt"); // could exhaust memory

// ✅ stream it in chunks (constant memory)
fs.createReadStream("10gb.txt").pipe(fs.createWriteStream("copy.txt"));
```

મોટી ફાઇલો માટે, `readFile` બધું એક વખતમાં મેમરીમાં લોડ કરે છે; **streams** સતત મેમરી સાથે ડેટાને ટુકડાઓમાં પ્રક્રિયા કરે છે.

## તે શા માટે મહત્વનું છે

ફાઇલ I/O એ Node માટે કોર ક્ષમતા છે કોન્ફિગ લોડિંગ, લૉગીંગ, ફાઇલ અપલોડ/ડાઉનલોડ્સ અને ટુલિંગ માટે.

તીન API શૈલીઓ વિશે જ્ઞાન — અને નિર્ણાયક રીતે, કે **sync પદ્ધતિઓ ઇવેન્ટ લૂપને અવરોધિત કરે છે** (સર્વરોમાં તેમને ટાળો) અને કે **મોટી ફાઇલો streams ની જરૂર છે** (ન કે `readFile`) — સમવર્તન હેઠળ સાચી અને કાર્યક્ષમ બંને ફાઇલ-હ્યાન્ડલિંગ કોડ લખવા માટે આવશ્યક છે.

Async/await સાથે promise API એ રોજિંદા ઉપયોગ માટે સ્વચ્છ ડિફૉલ્ટ છે.