Come esegui processi esterni con child_process?

Question

Accepted Answer

Il modulo **`child_process`** consente a Node di eseguire **altri programmi/comandi** (comandi della shell, script, altri binary) come processi OS separati. Utile per invocare strumenti di sistema, eseguire operazioni CPU-intensive al di fuori del processo principale, o orchestrare altri programmi.

## I quattro metodi principali

```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 — semplice, bufferizzato

```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` è conveniente per comandi brevi ma bufferizza tutto l'output — rischioso per comandi che producono output elevato (può superare il limite del buffer).

## spawn — streaming (per output grande/continuo)

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

`spawn` effettua lo streaming dell'output mentre viene prodotto (memoria costante) e accetta gli argomenti come **array** (non una stringa shell) — la scelta giusta per processi a lunga esecuzione o ad alto output.

## L'avvertimento sulla sicurezza: 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
```

Non interpolare mai input non attendibile in una stringa shell `exec` — abilita **command injection**. Usa `execFile`/`spawn` con un array di argomenti in modo che l'input venga passato come dati, non come sintassi shell.

## Utilizzo basato su Promise

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

## Perché è importante

`child_process` consente a Node di integrarsi con il sistema più ampio — eseguire strumenti CLI (git, ffmpeg, imagemagick), offloadare operazioni CPU-intensive a processi separati (evitando il blocco dell'event loop), e orchestrare altri programmi.

Sapere quale metodo utilizzare (`spawn` per streaming/output elevato, `exec` per comandi semplici, `fork` per sottoprocessi Node) e — criticamente — il **rischio di command injection** di `exec` con input dell'utente (mitigato da `execFile`/`spawn` con array di arg) è essenziale per utilizzarlo sia efficacemente che in sicurezza.