તમે child_process સાથે બાહ્ય પ્રક્રિયાઓ કેવી રીતે ચલાવો છો?

Question

Accepted Answer

**`child_process`** મોડ્યુલ Node ને **અન્ય પ્રોગ્રામ્સ/આદેશો** (શેલ આદેશો, સ્ક્રિપ્ટો, અન્ય બાઈનરીઝ) એલગ OS પ્રક્રિયા તરીકે ચલાવવા દે છે. સિસ્ટમ ટૂલ્સ (git, ffmpeg) આમંત્રણ, 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` ટૂંકા આદેશો માટે સુવિધાજનક છે પણ બધી આઉટપુટ બફર કરે છે — આદેશો માટે જોખમી જે વધુ આઉટપુટ ઉત્પન્ન કરે છે (બફર લિમિટ ઓવરલોડ કરી શકે છે).

## spawn — streaming (મોટી/સતત આઉટપુટ માટે)

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

`spawn` આઉટપુટ સ્ટ્રીમ કરે છે કારણ કે તે ઉત્પન્ન થાય છે (સ્થિર મેમરી) અને આર્ગ્યુમેન્ટો **array** તરીકે લે છે (શેલ સ્ટ્રિંગ નહીં) — લાંબી-ચાલતી અથવા ઉચ્ચ-આઉટપુટ પ્રક્રિયા માટે સાચો પસંદ.

## સુરક્ષા ચેતવણી: 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` શેલ સ્ટ્રિંગમાં ક્યારેય પ્રક્ષેપ કરશો નહીં — તે **command injection** સક્ષમ કરે છે. ઇનપુટ ડેટા તરીકે પસાર થાય છે તે માટે `execFile`/`spawn` ને આર્ગ્યુમેન્ટ array સાથે વાપરો, શેલ સિન્ટેક્સ નહીં.

## Promise-આધારિત ઉપયોગ

```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-ગુરુતર કાર્ય અલગ પ્રક્રિયામાં અપસેટ કરવું (ઇવેન્ટ લૂપ બ્લોક કરવાનું સંચય), અને અન્ય પ્રોગ્રામ્સને ગોઠવવું.

કયો પદ્ધતિ (શેલ સ્ટ્રીમિંગ/મોટી આઉટપુટ માટે `spawn`, સરળ આદેશો માટે `exec`, Node સબપ્રોસેસેસ માટે `fork`) વાપરવું અને — ગુણવત્તાપૂર્વક — ব્યુજર ઇનપુટ સાથે `exec` નો **command-injection જોખમ** (`execFile`/`spawn` સાથે arg arrays દ્વારા ઘટાડવામાં આવે છે) તેને અસરકારક અને સુરક્ષિત રીતે ઉપયોગ કરવા માટે આવશ્યક છે.