Hvordan kører du eksterne processer med child_process?

Question

Accepted Answer

Modulet **`child_process`** lader Node køre **andre programmer/kommandoer** (shell-kommandoer, scripts, andre binærer) som separate OS-processer. Brugbart til at påberåbe sig systemværktøjer, køre CPU-tung arbejde uden for hovedprocessen eller orkestrere andre programmer.

## De fire hovedmetoder

```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 — enkel, bufret

```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` er praktisk til korte kommandoer, men bufrer hele outputtet — risikabelt for kommandoer, der producerer stort output (kan overskride bufferlimits).

## spawn — streaming (til stort/kontinuerlig output)

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

`spawn` streamer output efterhånden som det produceres (konstant hukommelse) og tager argumenter som et **array** (ikke en shell-streng) — det rigtige valg for længerevarende eller højt output-processer.

## Sikkerhedsadvarsel: kommandoinjektion

```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
```

Interpol aldrig utroværdigt input til en `exec` shell-streng — det muliggør **kommandoinjektion**. Brug `execFile`/`spawn` med et argumentarray, så input sendes som data, ikke shell-syntaks.

## Promise-baseret brug

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

## Hvorfor det betyder noget

`child_process` lader Node integrere sig med det bredere system — køre CLI-værktøjer (git, ffmpeg, imagemagick), aflaste CPU-tungt arbejde til separate processer (undgå blokering af event loop) og orkestrere andre programmer.

At vide, hvilken metode man skal bruge (`spawn` til streaming/stort output, `exec` til enkle kommandoer, `fork` til Node-underprocesser) og — kritisk — **kommandoinjektion-risikoen** ved `exec` med brugerinput (afbødet af `execFile`/`spawn` med argument-arrays) er væsentlig for at bruge det både effektivt og sikkert.