ਤੁਸੀਂ child_process ਨਾਲ ਬਾਹਰੀ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਕਿਵੇਂ ਚਲਾਉਂਦੇ ਹੋ?

Question

Accepted Answer

**`child_process`** ਮੌਡੀਊਲ Node ਨੂੰ **ਹੋਰ ਪ੍ਰੋਗ੍ਰਾਮ/ਕਮਾਂਡਾਂ** (ਸ਼ੈਲ ਕਮਾਂਡਾਂ, ਸਕ੍ਰਿਪਟਾਂ, ਹੋਰ ਬਾਇਨਰੀਜ਼) ਨੂੰ ਵੱਖ-ਵੱਖ OS ਪ੍ਰਕਿਰਿਆਵਾਂ ਵਜੋਂ ਚਲਾਉਣ ਦਿੰਦਾ ਹੈ। ਸਿਸਟਮ ਟੂਲਸ (git, ffmpeg ਆਦਿ) ਨੂੰ ਸੱਦਣ, CPU-ਭਾਰੀ ਕੰਮ ਨੂੰ ਮੁੱਖ ਪ੍ਰਕਿਰਿਆ ਤੋਂ ਬਾਹਰ ਚਲਾਉਣ, ਜਾਂ ਹੋਰ ਪ੍ਰੋਗ੍ਰਾਮਾਂ ਦਾ ਸਮਨਵਯ ਕਰਨ ਲਈ ਮਫ਼ੀਦ ਹੈ।

## ਚਾਰ ਮੁੱਖ ਤਰੀਕੇ

```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 — ਸਰਲ, 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
});
```

`exec` ਛੋਟੀਆਂ ਕਮਾਂਡਾਂ ਲਈ ਸੁਵਿਧਾਜਨਕ ਹੈ ਪਰ ਸਾਰੇ ਆਉਟਪੁੱਟ ਨੂੰ buffer ਕਰਦਾ ਹੈ — ਭਾਰੀ ਆਉਟਪੁੱਟ ਪੈਦਾ ਕਰਨ ਵਾਲੀਆਂ ਕਮਾਂਡਾਂ ਲਈ ਖਤਰਨਾਕ (buffer limit ਤੋਂ ਵੱਧ ਸਕਦਾ ਹੈ)।

## spawn — streaming (ਵੱਡੇ/ਲਗਾਤਾਰ ਆਉਟਪੁੱਟ ਲਈ)

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

`spawn` ਆਉਟਪੁੱਟ ਨੂੰ stream ਕਰਦਾ ਹੈ ਜਿਵੇਂ ਇਹ ਪੈਦਾ ਹੁੰਦਾ ਹੈ (ਸਥਿਰ ਮੈਮੋਰੀ) ਅਤੇ arguments ਨੂੰ **array** ਦੇ ਤੌਰ 'ਤੇ ਲੈਂਦਾ ਹੈ (shell string ਨਹੀਂ) — ਲੰਮੀ-ਮਿਆਦ ਜਾਂ ਉੱਚ-ਆਉਟਪੁੱਟ ਪ੍ਰਕਿਰਿਆਵਾਂ ਲਈ ਸਹੀ ਵਿਕਲਪ।

## ਸੁਰੱਖਿਆ ਦੀ ਚੇਤਾਵਨੀ: 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
```

ਕਦੇ ਵੀ `exec` shell string ਵਿੱਚ ਭਰੋਸੇਮੰਦ ਨਹੀਂ ਡੇਟਾ ਨੂੰ interpolate ਨਾ ਕਰੋ — ਇਹ **command injection** ਨੂੰ ਸਖ਼ਤ ਬਣਾਉਂਦਾ ਹੈ। `execFile`/`spawn` ਨੂੰ arguments array ਦੇ ਨਾਲ ਵਰਤੋ ਤਾਂ ਕਿ ਇਨਪੁੱਟ ਨੂੰ ਡੇਟਾ ਦੇ ਤੌਰ 'ਤੇ, shell syntax ਨਹੀਂ, ਭੇਜਿਆ ਜਾਵੇ।

## Promise-based usage

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

## ਇਹ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ

`child_process` Node ਨੂੰ ਵਿਆਪਕ ਸਿਸਟਮ ਦੇ ਨਾਲ ਜੋੜਿਆ ਜਾ ਸਕਦਾ ਹੈ — CLI tools ਨੂੰ ਚਲਾਉਣਾ (git, ffmpeg, imagemagick), CPU-ਭਾਰੀ ਕੰਮਾਂ ਨੂੰ ਵੱਖਰੀਆਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਦਿਖਾਉਣਾ (event loop ਨੂੰ ਅਵਰੁੱਧ ਕਰਨ ਤੋਂ ਬਚਣਾ), ਅਤੇ ਹੋਰ ਪ੍ਰੋਗ੍ਰਾਮਾਂ ਦਾ ਸਮਨਵਯ ਕਰਨਾ।

ਇਹ ਜਾਣਨਾ ਕਿ ਕਿਸ method ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਹੈ (`spawn` streaming/ਵੱਡੇ ਆਉਟਪੁੱਟ ਲਈ, `exec` ਸਰਲ ਕਮਾਂਡਾਂ ਲਈ, `fork` Node subprocesses ਲਈ) ਅਤੇ — ਮਹੱਤਵਪੂਰਨ ਤੌਰ 'ਤੇ — `exec` ਦਾ **command-injection risk** ਵਰਤਕਾਰ ਇਨਪੁੱਟ ਦੇ ਨਾਲ (`execFile`/`spawn` ਦੁਆਰਾ arg arrays ਨਾਲ ਘਟਾਇਆ ਜਾਂਦਾ ਹੈ) ਇਸ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਅਤੇ ਸੁਰੱਖਤ ਤਰੀਕੇ ਨਾਲ ਵਰਤਣ ਲਈ ਜਰੂਰੀ ਹੈ।