आप 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 रोज़मर्रा के उपयोग के लिए स्वच्छ डिफ़ॉल्ट है।