Hoe voer je externe processen uit met child_process?

Question

Accepted Answer

De **`child_process`** module stelt Node in staat **andere programma's/commando's** (shell-commando's, scripts, andere binaries) als afzonderlijke OS-processen uit te voeren. Nuttig voor het aanroepen van systeemtools, het uitvoeren van CPU-zware taken buiten het hoofdproces, of het orkestreren van andere programma's.

## De vier hoofdmethoden

```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 — eenvoudig, gebufferd

```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` is handig voor korte commando's maar buffert alle uitvoer — riskant voor commando's die grote hoeveelheden uitvoer produceren (kan de bufferlimiet overschrijden).

## spawn — streaming (voor grote/continue uitvoer)

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

`spawn` streamt uitvoer terwijl deze wordt geproduceerd (constant geheugen) en accepteert argumenten als **array** (geen shell-string) — de juiste keuze voor langdurige of high-output processen.

## De veiligheidswaarschuwing: 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
```

Interpoleer nooit onbetrouwde invoer in een `exec` shell-string — dit maakt **command injection** mogelijk. Gebruik `execFile`/`spawn` met een argument array zodat invoer als data wordt doorgegeven, niet als shell-syntaxis.

## Op Promise gebaseerd gebruik

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

## Waarom het belangrijk is

`child_process` stelt Node in staat om zich in het bredere systeem te integreren — CLI-tools (git, ffmpeg, imagemagick) uit te voeren, CPU-zware taken naar afzonderlijke processen uit te voeren (voorkoming van het blokkeren van de event loop) en andere programma's in te richten.

Weten welke methode je moet gebruiken (`spawn` voor streaming/grote uitvoer, `exec` voor eenvoudige commando's, `fork` voor Node subprocessen) en — vooral — het **command-injection risico** van `exec` met gebruikersinvoer (beperkt door `execFile`/`spawn` met argument arrays) is essentieel voor het effectief en veilig gebruiken ervan.