Cum rulezi procese externe cu child_process?

Question

Accepted Answer

Modulul **`child_process`** permite Node să execute **alte programe/comenzi** (comenzi shell, scripturi, alte binare) ca procese OS separate. Util pentru invocarea unor instrumente de sistem, rularea unor sarcini grele din punct de vedere CPU în afara procesului principal sau orchestrarea altor programe.

## Cele patru metode principale

```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 — simplu, buferat

```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` este convenabil pentru comenzi scurte, dar pune în buffer toată ieșirea — riscant pentru comenzi care produc o ieșire mare (poate depăși limita buffer-ului).

## spawn — streaming (pentru ieșire mare/continuă)

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

`spawn` transmite ieșirea pe măsură ce este produsă (memorie constantă) și acceptă argumente ca **array** (nu un șir shell) — alegerea corectă pentru procese de lungă durată sau cu ieșire mare.

## Avertismentul de securitate: 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
```

Nu interpola niciodată intrarea de neîncredere într-un șir shell `exec` — aceasta permite **command injection**. Folosește `execFile`/`spawn` cu un array de argumente, astfel încât intrarea să fie trecută ca date, nu sintaxă shell.

## Utilizare bazată pe Promise

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

## De ce este important

`child_process` permite Node să se integreze cu sistemul mai larg — rularea unor instrumente CLI (git, ffmpeg, imagemagick), descărcarea sarcinilor grele din punct de vedere CPU către procese separate (evitând blocarea event loop-ului) și orchestrarea altor programe.

Cunoașterea metodei de utilizat (`spawn` pentru streaming/ieșire mare, `exec` pentru comenzi simple, `fork` pentru subprocese Node) și — în mod critic — **riscul de command injection** al `exec` cu intrare de utilizator (atenuat de `execFile`/`spawn` cu array-uri arg) este esențial pentru a o folosi atât eficient, cât și în mod securizat.