child_process ஐ பயன்படுத்தி வெளிப்புற செயல்முறைகளை எவ்வாறு চালை?

Question

Accepted Answer

**`child_process`** தொகுதி Node ஐ **பிற நிரல்கள்/கட்டளைகள்** (shell கட்டளைகள், வசன வாক்கியங்கள், பிற பைனரிகள்) தனித்தனி OS செயல்முறைகளாக நடைமுறைப்படுத்த அனுமதிக்கிறது. கணினி கருவிகளைக் குறிப்பிடுவதற்கு, CPU-கனமான வேலையை முக்கிய செயல்முறைக்கு வெளியே நடைமுறைப்படுத்துவதற்கு அல்லது பிற நிரல்களை ஆயத்த செய்வதற்கு பயனுள்ளதாக இருக்கிறது.

## நான்கு முக்கிய முறைகள்

```text
exec      → run a shell command, buffer all output (simple, small output)
execFile  → run a file directly (no shell — safer, faster)
spawn     → stream output (for large output / long-running processes)
fork      → spawn a new NODE process with an IPC channel (Node-to-Node)
```

## exec — எளிய, buffered

```js
import { exec } from "child_process";

exec("ls -la", (err, stdout, stderr) => {
  if (err) return console.error(err);
  console.log(stdout); // the entire output, buffered into memory
});
```

`exec` சிறுவயது கட்டளைகளுக்கு வசதியாக இருக்கிறது ஆனால் அனைத்து வெளியீடுகளையும் buffering செய்கிறது — பெரிய வெளியீட்டை உருவாக்கும் கட்டளைகளுக்கு ஆபத்தாக இருக்கிறது (buffer வரம்பை превышить செய்யலாம்).

## spawn — streaming (பெரிய/தொடர்ந்த வெளியீடுக்கு)

```js
import { spawn } from "child_process";

`spawn` உருவாக்கப்பட்ட போது வெளியீட்டை ஸ்ட்ரீম் செய்கிறது (நிலையான நினைவாற்றல்) மற்றும் வாதங்களை **array** ஆக எடுக்கிறது (shell சரம் அல்ல) — நீண்ட-இயங்கும் அல்லது உচ்च-வெளியீட்டு செயல்முறைகளுக்கான சரியான தேர்வு.

## பாதுகாப்பு எச்சரிக்கை: command injection

```js
// ❌ DANGEROUS — user input in a shell command enables injection
exec(`convert ${userFilename} out.png`); // userFilename = "; rm -rf /" → disaster

// ✅ use execFile/spawn with an args array — no shell interpolation
execFile("convert", [userFilename, "out.png"]); // args passed safely, not parsed by a shell
```

`exec` shell சரத்தில் நம்பமுடியாத உள்ளீட்டை interpolate செய்யாதீர்கள் — இது **command injection** அனுமதிக்கிறது. உள்ளீட்டை shell உபயோகிக்கை அல்ல தகவல்களாக அனுப்பப்படும் வகையில் வாதங்கள் array உடன் `execFile`/`spawn` ஐ பயன்படுத்துங்கள்.

## Promise-based usage

```js
import { promisify } from "util";
const execAsync = promisify(exec);
const { stdout } = await execAsync("git rev-parse HEAD");
```

## ஏன் இது முக்கியமாக உள்ளது

`child_process` Node ஐ பரந்த கணினி அமைப்பிற்கு ஒருங்கிணைக்க அனுமதிக்கிறது — CLI கருவிகளை நடைமுறைப்படுத்த (git, ffmpeg, imagemagick), CPU-கனமான பணிகளை தனித்தனி செயல்முறைகளுக்கு மாற்ற (event loop ஐ நிறுத்துவதைத் தவிர்க்க) மற்றும் பிற நிரல்களை ஆயத்த செய்ய.

ஏ முறை பயன்படுத்த வேண்டும் என்று தெரிந்து கொள்ள (`spawn` streaming/பெரிய வெளியீட்டுக்கு, `exec` எளிய கட்டளைகளுக்கு, `fork` Node subprocesses க்கு) மற்றும் — முக்கியமாக — பயனர் உள்ளீட்டுடன் `exec` இன் **command-injection ஆபத்து** (`execFile`/`spawn` arg arrays உடன் குறைக்கப்பட்டது) என்பது அதை பರிணாமம் மற்றும் பாதுகாப்பாக பயன்படுத்துவதற்கு அவசியமாக இருக்கிறது.