Hur kör du externa processer med child_process?

Question

Accepted Answer

Modulen **`child_process`** låter Node köra **andra program/kommandon** (shell-kommandon, skript, andra binärer) som separata OS-processer. Användbar för att anropa systemverktyg, köra CPU-tungt arbete utanför huvudprocessen eller dirigera andra program.

## De fyra huvudmetoderna

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

```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` är bekväm för korta kommandon men buffrar all utmatning — riskabelt för kommandon som producerar stor utmatning (kan överstiga buffertgränsen).

## spawn — streaming (för stor/kontinuerlig utmatning)

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

`spawn` streamar utmatning när den produceras (konstant minne) och tar argument som en **array** (inte en shell-sträng) — rätt val för långkörande eller högutmatningsprocesser.

## Säkerhetsvarningen: 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
```

Interpolera aldrig opålitlig inmatning i en `exec` shell-sträng — det möjliggör **command injection**. Använd `execFile`/`spawn` med en argumentarray så att inmatning skickas som data, inte shell-syntax.

## Promise-baserad användning

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

## Varför det spelar roll

`child_process` låter Node integreras med det större systemet — köra CLI-verktyg (git, ffmpeg, imagemagick), avlasta CPU-tungt arbete till separata processer (för att undvika att blockera event-loopen) och dirigera andra program.

Veta vilken metod du ska använda (`spawn` för streaming/stor utmatning, `exec` för enkla kommandon, `fork` för Node-delprocesser) och — kritiskt — **command-injection-risken** med `exec` och användarinmatning (minskas av `execFile`/`spawn` med arg-arrayer) är väsentligt för att använda det både effektivt och säkert.