Suggest an edit

Improve this article

Refine the answer for “What does the child_process module do?”. Your changes go to moderation before they’re published.

Approval required

Content

What you’re changing

Title (EN)

Short answer (EN)

Shown above the full answer for quick recall.

Answer (EN)

## What `child_process` is

> `child_process` is a built-in Node.js module
> that lets you **create child processes** from the current Node.js application.

In other words:

> It lets you run **other programs, scripts, or OS commands**,
> as if you'd typed them into a terminal.

## 1. Why `child_process` is needed

It lets you:

- run **system commands** (`ls`, `ping`, `git`, `python`, `ffmpeg`, and so on);
- launch **other Node.js scripts** as separate processes;
- run computation **in parallel**;
- **bridge** different languages and tools (for example, Node.js ↔ Python);
- build **CLI tools and pipelines** (UNIX-style).

## 2. The main methods of `child_process`

| Method | Returns | Description |
|---|---|---|
| `exec()` | a process object (`ChildProcess`) | Runs a command in a shell and buffers the result |
| `execFile()` | a process object | Runs an executable directly (no shell) |
| `spawn()` | a process object | Creates a streaming process, handy for large data |
| `fork()` | a process object | Launches a **new Node.js process** (with a built-in IPC channel) |

## 3. Examples of each method

### 1) `exec()`: run a command and get the result

```javascript
const { exec } = require('child_process');

exec('ls -la', (error, stdout, stderr) => {
  if (error) console.error(`Error: ${error.message}`);
  if (stderr) console.error(`STDERR: ${stderr}`);
  console.log(`Result:\n${stdout}`);
});
```

Good for:

- simple commands;
- getting a **finished result** as text;
- small amounts of output.

But! `exec()` **buffers all output in memory**,
so for large data `spawn()` is a better fit.

### 2) `spawn()`: a streaming process launch

```javascript
const { spawn } = require('child_process');

const child = spawn('ping', ['google.com']);

child.stdout.on('data', (data) => {
  console.log(`Output: ${data}`);
});

child.stderr.on('data', (data) => {
  console.error(`Error: ${data}`);
});

child.on('close', (code) => {
  console.log(`Process exited with code ${code}`);
});
```

Good for:

- **long-running processes** (for example, `ffmpeg`, `npm run`, `curl`);
- processing data **in real time** (through `stdout`, `stderr`).

### 3) `execFile()`: run a specific file

```javascript
const { execFile } = require('child_process');

execFile('node', ['-v'], (error, stdout) => {
  if (error) throw error;
  console.log(`Node.js version: ${stdout}`);
});
```

The difference from `exec()`:

- doesn't use a shell (`bash`, `cmd`);
- faster and safer (less risk of command injection);
- a great fit for **calling executables or scripts**.

### 4) `fork()`: launch a new Node.js process

```javascript
const { fork } = require('child_process');

const child = fork('worker.js');

child.on('message', (msg) => console.log('Response from the worker:', msg));
child.send({ task: 'compute', value: 5 });
```

**worker.js**

```javascript
process.on('message', (msg) => {
  const result = msg.value * 2;
  process.send({ result });
});
```

Features of `fork()`:

- used **only for Node.js files**;
- creates a **separate Node.js process**;
- supports a **built-in message channel (IPC)**;
- great for **parallel computation** and **modular architecture**.

## 4. Events on the `ChildProcess` object

| Event | Description |
|---|---|
| `exit` | The process has finished |
| `close` | All I/O streams have been closed |
| `error` | An error happened at launch |
| `message` | A message was received (for `fork()`) |
| `disconnect` | The IPC channel was closed |

## 5. Comparing the methods

| Method | Uses a shell | Returns the result | Streaming I/O | Typical task |
|---|---|---|---|---|
| `exec` | Yes | As a string (`stdout`) | No | Simple commands |
| `execFile` | No | As a string (`stdout`) | No | Running executables |
| `spawn` | No | Streams (`stdout`, `stderr`) | Yes | Streaming work |
| `fork` | No | Via IPC messages | Yes | Launching Node.js workers |

## 6. Where it's used in practice

**Real-world scenarios:**

- running Python or Go programs from Node.js;
- building custom CLI commands;
- image processing via `ImageMagick`, `ffmpeg`, `sharp`;
- integrating with `git`, `docker`, `kubectl`;
- distributing computation across several processes;
- running cron jobs.

## 7. Worth remembering

- Every process has **its own memory and event loop**.
- Data exchange between processes happens via **IPC** (Inter-Process Communication).
- `exec()` can hang if its buffer overflows (1 MB by default).
- For many parallel tasks, **worker_threads** is usually better (lighter than processes).
- **PM2** or clustering (`cluster`) is often used to manage many processes.

## Summary

| Criterion | `child_process` |
|---|---|
| Purpose | Launching external programs and processes |
| API type | Asynchronous (callbacks or events) |
| Methods | `exec`, `execFile`, `spawn`, `fork` |
| Stream support | Via `stdout` / `stderr` |
| Data exchange | Via messages (IPC) or I/O |
| Use it for | Integrating with external commands, parallel computation, automation |

**Conclusion:**

> The `child_process` module makes Node.js an "orchestrator",
> it can launch any program, manage it,
> pass it data and get results back.
>
> It's the foundation for CLI tools, DevOps scripts, build systems and distributed computation.

Markdown · drag & drop images · ⌘B / ⌘I shortcuts809 words

For the reviewer

Note to the moderator (optional)

Visible only to the moderator. Helps review go faster.