Hvordan kjører du eksterne prosesser med child_process?

Question

Accepted Answer

**`child_process`** modulen lar Node kjøre **andre programmer/kommandoer** (shell-kommandoer, skript, andre binærer) som separate OS-prosesser. Nyttig for å påkalle systemverktøy, kjøre CPU-intensivt arbeid utenfor hovedprosessen, eller orkestrere andre programmer.

## De fire hovedmetodene

```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 for korte kommandoer, men bufrer all utdata — risikabel for kommandoer som produserer stor utdata (kan overskride buffergensen).

## spawn — streaming (for stor/kontinuerlig utdata)

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

`spawn` strømmer utdata etter hvert som den produseres (konstant minne) og tar argumenter som en **array** (ikke en shell-streng) — riktig valg for langvarige eller høy-utdata-prosesser.

## Sikkerhetsadvarsel: kommandoinjeksjon

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

Aldri interpol upålitelig inndata i en `exec` shell-streng — det muliggjør **kommandoinjeksjon**. Bruk `execFile`/`spawn` med en argumentarray slik at inndata sendes som data, ikke shell-syntaks.

## Promise-basert bruk

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

## Hvorfor det er viktig

`child_process` lar Node integreres med det større systemet — kjøre CLI-verktøy (git, ffmpeg, imagemagick), avlaste CPU-intensive oppgaver til separate prosesser (unngår blokkering av event-løkken), og orkestrere andre programmer.

Å vite hvilken metode som skal brukes (`spawn` for streaming/stor utdata, `exec` for enkle kommandoer, `fork` for Node-underprosesser) og — kritisk — **kommandoinjeksjonsrisikoen** til `exec` med brukerinndata (redusert ved `execFile`/`spawn` med arg-arrays) er essensielt for å bruke det både effektivt og sikkert.