Conas a ritheann tú próiseas seachtracha le child_process?

Question

Accepted Answer

Ligeann an modúl **`child_process`** do Node **clár eile/orduithe eile** (orduithe blaoisce, scripteanna, binaries eile) a rith mar phróiseas OS ar leith. Úsáideach chun uirlisí córais a ghlaoigh, obair dhomhain-CPU a rith lasmuigh den phríomhphróiseas, nó clár eile a eagrú.

## Na ceithre phríomhdhóigh

```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 — simplí, buffered

```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
});
```

Tá exec áisiúil do orduithe gearr ach buffers sé an fhísolathar ar fad — baolach do orduithe a tháirgeann aschur mór (is féidir an teorainn buffering a shárú).

## spawn — streaming (d'aschur mór/leanúnach)

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

Déanann spawn sruthú ar aschur agus a tháirgtear (cuimhne tairiseach) agus glacann sé argóintí mar **array** (ní teanga blaoisce) — an rogha cheart do phróiseas fada-rith nó ard-aschur.

## An rabhadh slándála: injection ordaithe

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

Ná cuir isteach riamh ionchur neamhiontaofa i teanga blaoisce `exec` — cumasaíonn sé **injection ordaithe**. Úsáid `execFile`/`spawn` le array argóintí ionas go ndéantar ionchur a rith mar shonraí, ní mar bhreicsyntax blaoisce.

## Úsáid bhunaithe ar Ghealltanas

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

## Cén fáth a bhfuil tábhacht ann

Ligeann `child_process` do Node an fhuinneamh leathan a bhaint amach — uirlisí CLI a rith (git, ffmpeg, imagemagick), tascanna domhain-CPU a dhíbirt go próiseas ar leith (ag seachaint blocáil an lúb imeachta), agus clár eile a eagrú.

A bheith ar eolas cén modh a úsáid (`spawn` do streaming/aschur mór, `exec` do orduithe simplí, `fork` do phróceas subpróiseas Node) agus — go criticiúil — an **baol command-injection** de `exec` le ionchur úsáideora (laghdaithe ag `execFile`/`spawn` le arrays arg) tá sé riachtanach chun é a úsáid go héifeachtach agus go slán.