path தொகுதியைப் பயன்படுத்துவது ஏன் சரம் இணைப்பை விட சிறந்தது?

Question

Accepted Answer

உள்ளமைக்கப்பட்ட **`path`** தொகுதி **இயக்க முறைமைகள் முழுவதும்** கோப்பு பாதைகளை சரியாக உருவாக்கி கையாளுகிறது. `/` மூலம் பாதை சரங்களை கையால் இணைப்பது Windows இல் உடைந்துவிடும் (`\` ஐ பயன்படுத்துகிறது) மற்றும் விளிம்பு நிகழ்வுகளை தவறாக கையாளுகிறது — `path` இதை நির்ভরத்தோடு கையாளுகிறது.

## சரம் இணைப்பின் சிக்கல்

```js
// ❌ fragile, OS-dependent, error-prone
const filePath = baseDir + "/" + "sub" + "/" + fileName;
// breaks on Windows (\), doubles slashes if baseDir ends in /, etc.
```

## தீர்வு: path.join

```js
import path from "path";

// ✅ uses the correct separator for the OS, normalizes slashes
const filePath = path.join(baseDir, "sub", fileName);
// Linux/Mac: baseDir/sub/file.txt   Windows: baseDir\sub\file.txt
```

`path.join` சரியான பிரிப்பியைச் செருகுகிறது, நகலான/பின்னொட்ட சாய்வுகளை சிதைக்கிறது, மற்றும் `..`/`.` பிரிவுகளை தீர்க்கிறது.

## பிற அপরिহार்य path செயல்பாடுகள்

```js
path.resolve("src", "app.js");  // → ABSOLUTE path from the cwd
path.basename("/a/b/file.txt");  // "file.txt"
path.dirname("/a/b/file.txt");   // "/a/b"
path.extname("file.txt");        // ".txt"
path.parse("/a/b/file.txt");     // { dir, base, name, ext }
path.sep;                         // "/" or "\" depending on OS
```

## தற்போதைய கோப்பின் கோப்புறையைப் பெறுதல்

```js
// CommonJS — built-in globals
const configPath = path.join(__dirname, "config.json");

// ES Modules — __dirname doesn't exist; derive it from import.meta.url
import { fileURLToPath } from "url";
const __dirname = path.dirname(fileURLToPath(import.meta.url));
```

தற்போதைய கோப்புக்கு சார்ந்த பாதைகளை உருவாக்குவது (`__dirname` உடன், அல்லது அதன் ESM சமதுல்യம்) கோப்புகளைக் குறிப்பிடுவதற்கான பாதுகாப்பான வழி — செயல்முறை எங்கிருந்து தொடங்கியது என்பதைப் பொருட்படுத்தாமல்।

## join vs resolve

```text
path.join    → just joins segments (relative stays relative)
path.resolve → produces an ABSOLUTE path (resolves from cwd / right-to-left)
```

## ஏன் இது முக்கியம்

சரம் இணைப்பின் பதிலாக `path` ஐ பயன்படுத்துவது கோப்பு-கையாளும் நிறை **தாங்குதல் மற்றும் உறுதியை** செய்கிறது — Mac/Linux இல் எழுதப்பட்ட குறி Windows இல் உடைந்துவிடும் அல்லது இணைப்பு தவறான பாதைகளை உருவாக்கும் போது ஒரு அடிக்கடி பிழை மூலம்.

இது ஒரு சிறிய பழக்கம் ஆனால் பெரிய நம்பகத்தன்மை சலுகைகளுடன் வருகிறது, மற்றும் `join` vs `resolve` பற்றிய அறிவு, மற்றும் ESM இல் `__dirname` பெறுவது, கோப்பு முறைமையைத் தொடும் எந்த Node திட்டத்திலும் இன்றைய பாதை தேவைகளை உள்ளடக்குகிறது.