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 உடன் தினசரி பயன்பாட்டிற்கான நேர்த்தியான இயல்பிணை.