ਤੁਸੀਂ 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 ਨੂੰ ਬਲੌਕ ਕਰਦੇ ਹਨ** ਜਦੋਂ ਤਕ ਓਪਰੇਸ਼ਨ ਮੁਕਮਲ ਨਹੀਂ ਹੁੰਦੀ। ਇਹ ਸਟਾਰਟਅਪ ਵਿੱਚ ਠੀਕ ਹਨ (ਕਾਨਫਿਗ ਇੱਕ ਵਾਰ ਲੋਡ ਕਰਨਾ), ਪਰ request ਹ্যান্ডਲਰਾਂ ਵਿੱਚ ਪਰਹੇਜ਼ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ — ਇੱਕ ਬਲੌਕਿੰਗ ਰੀਡ ਸਾਰੇ ਸਮਕਾਲੀ ਬੇਨਤੀਆਂ ਨੂੰ ਫ੍ਰੀਜ਼ ਕਰਦਾ ਹੈ।

## ਆਮ ਓਪਰੇਸ਼ਨ

```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`) — ਫਾਇਲ-ਹ্যান্ਡਲਿੰਗ ਕੋਡ ਲਿਖਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ ਜੋ ਦੋਵਾਂ ਸਹੀ ਅਤੇ ਸਮਕਾਲੀ ਅਧੀਨ ਕਾਰਕਰਦਗੀ ਵਾਲੀ ਹੋ।

Promise API async/await ਦੇ ਨਾਲ ਰੋਜ਼ਾਨਾ ਵਰਤੋਂ ਲਈ ਸਾਫ ਮਨਜ਼ੂਰ ਹੈ।