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` పద్ధతులు **మొత్తం event loop ను నిరోధిస్తాయి** ఆపరేషన్ పూర్తయ్యే వరకు. అవి ప్రారంభంలో సరిపోతాయి (ఒకసారి కాన్ఫిగ్ లోడ్ చేయడం) కానీ రిక్వెస్ట్ హ్యాండ్లర్‌లలో నివారించాలి — ఆపే చదవడం అన్ని సమకాలీన అభ్యర్థనలను కొవ్వకుండా చేస్తుంది.

## సాధారణ ఆపరేషన్‌లు

```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 పద్ధతులు event loop ను నిరోధిస్తాయి** (సర్వర్‌లలో వాటిని నివారించండి) మరియు **పెద్ద ఫైల్‌లకు streams అవసరం** (కాదు `readFile`) — సరైన మరియు పనితీరు కలిగిన ఫైల్-చర్య కోడ్ వ్రాయడానికి చాలా ముఖ్యమైనది concurrency లో.

Promise API async/await సాথ దైనందిన ఉపయోగం కోసం స్వచ్ఛ సాధారణం.