Handling child process errors in Node.js - Step-by-Step Execution

Concept Flow - Handling child process errors

Start child process

↓

Child process runs

↓

Error occurs?

No→Process ends successfully

Yes↓

Emit 'error' event

↓

Error handler runs

↓

Log or handle error

↓

Process ends with error

This flow shows how a Node.js child process starts, runs, and if an error happens, it emits an error event that is caught and handled.

Execution Sample

Node.js

import { spawn } from 'child_process';

const child = spawn('invalidCommand');

child.on('error', (err) => {
  console.error('Error:', err.message);
});

This code tries to run a non-existing command and listens for errors emitted by the child process.

Execution Table

Step	Action	Evaluation	Result
1	Spawn child process with 'invalidCommand'	Command not found	Child process emits 'error' event
2	Error event listener triggers	Receives error object	Logs error message 'Error: spawn invalidCommand ENOENT'
3	Process ends	No further events	Child process terminates with error

💡 Child process fails to start due to invalid command, triggering error event and ending process

Variable Tracker

Variable	Start	After Step 1	After Step 2	Final
child	undefined	ChildProcess object created	Error event listener attached	Child process terminated with error

Key Moments - 2 Insights

Why does the 'error' event get emitted instead of 'exit' when the command is invalid?

Because the child process fails to start at all, Node.js emits an 'error' event immediately (see execution_table step 1), not an 'exit' event which happens after a process runs.

What happens if we don't attach an 'error' event listener?

The program will crash with an uncaught error when the child process fails to start, as shown by the error event in execution_table step 2 requiring a handler.

Visual Quiz - 3 Questions

Look at the execution table, what happens at step 2?

A The error event listener runs and logs the error message

B The child process starts successfully

C The process exits without error

D The command runs and outputs data

💡 Hint

Check the 'Action' and 'Result' columns in execution_table row 2

At which step does the child process emit the 'error' event?

A Step 3

B Step 1

C Step 2

D No error event is emitted

💡 Hint

Look at the 'Evaluation' column in execution_table row 1

If the command was valid, how would the execution table change?

A The process would emit an 'error' event anyway

B The error event listener would still run

C There would be no 'error' event emitted in step 1

D The child variable would be undefined

💡 Hint

Refer to the 'Result' column in execution_table row 1 about error emission

Concept Snapshot

Handling child process errors in Node.js:
- Use spawn() to start a child process.
- Attach an 'error' event listener to catch startup errors.
- If the command is invalid, 'error' event fires immediately.
- Without error handler, program crashes on startup failure.
- Always handle 'error' to keep your app stable.

Full Transcript

This lesson shows how Node.js handles errors when starting child processes. When you use spawn() to run a command, if the command does not exist, the child process cannot start. Node.js then emits an 'error' event. You must listen for this event to catch the error and prevent your program from crashing. The example code runs an invalid command and logs the error message when the 'error' event fires. The execution table traces these steps: spawning the process, error event emission, error handling, and process termination. Key points include understanding why 'error' fires instead of 'exit' and the importance of attaching an error listener. The quiz tests your understanding of these steps and what changes if the command is valid.

Practice

1. What is the main reason to listen for the 'error' event when using Node.js child processes?

easy

A. To catch errors that happen when starting or running the child process

B. To get the output data from the child process

C. To close the child process manually

D. To restart the child process automatically

Solution

1. Step 1: Understand the purpose of the 'error' event

   The 'error' event is triggered if the child process fails to start or encounters a problem during execution.

2. Step 2: Differentiate from other events

   The 'exit' event tells when the process ends, but 'error' specifically catches startup or runtime errors.

3. Final Answer:

   To catch errors that happen when starting or running the child process -> Option A

4. Quick Check:

   'error' event = catch process startup/runtime errors [OK]

Hint: Remember: 'error' means process failed to start or crashed [OK]

Common Mistakes:

• Confusing 'error' with 'exit' event
• Thinking 'error' gives output data
• Assuming 'error' restarts the process

2. Which of the following is the correct way to listen for errors on a child process created with spawn?

easy

A. child.on('error', (err) => { console.error(err); });

B. child.error((err) => { console.error(err); });

C. child.on('exit', (code) => { console.log(code); });

D. child.catch('error', (err) => { console.error(err); });

Solution

1. Step 1: Recall the correct event listener syntax

   Node.js child processes use on method to listen for events like 'error'.

2. Step 2: Identify the correct event and method

   child.on('error', (err) => { console.error(err); }); uses child.on('error', callback), which is the proper syntax to catch errors.

3. Final Answer:

   child.on('error', (err) => { console.error(err); }); -> Option A

4. Quick Check:

   Use on('error') to catch errors [OK]

Hint: Use child.on('error', callback) to catch errors [OK]

Common Mistakes:

• Using wrong method like .error() or .catch()
• Listening to 'exit' instead of 'error' for errors
• Missing parentheses or wrong event name

3. Consider this code snippet:

const { spawn } = require('child_process');
const child = spawn('node', ['-e', "process.exit(1)"]);
child.on('exit', (code) => {
  console.log('Exit code:', code);
});
child.on('error', (err) => {
  console.error('Error:', err);
});

What will be printed when this runs?

medium

A. Exit code: 0

B. Error: Error message

C. Exit code: 1

D. No output

Solution

1. Step 1: Understand the child process command

   The child runs a Node.js command that immediately exits with code 1 using process.exit(1).

2. Step 2: Check which event triggers

   The process exits normally with code 1, so the 'exit' event fires with code 1; no 'error' event occurs.

3. Final Answer:

   Exit code: 1 -> Option C

4. Quick Check:

   process.exit(1) triggers 'exit' with code 1 [OK]

Hint: process.exit(n) triggers 'exit' with code n, no 'error' [OK]

Common Mistakes:

• Thinking exit code 1 triggers 'error' event
• Expecting 'Exit code: 0' by default
• Ignoring the 'exit' event output

4. You wrote this code to handle errors:

const { exec } = require('child_process');
const child = exec('invalidcommand');
child.on('exit', (code) => {
  if (code !== 0) console.log('Process failed');
});

Why might this code fail to detect the error properly?

medium

A. Because 'exit' event does not fire on errors

B. Because 'error' event should be used to catch command not found errors

C. Because exec does not emit any events

D. Because the callback function is missing

Solution

1. Step 1: Understand exec error handling

   When a command is invalid, exec emits an 'error' event, not just an 'exit' event with a code.

2. Step 2: Identify missing error listener

   The code listens only to 'exit', so it misses errors like 'command not found' which trigger 'error' event.

3. Final Answer:

   Because 'error' event should be used to catch command not found errors -> Option B

4. Quick Check:

   Use 'error' event to catch exec command failures [OK]

Hint: Listen to 'error' event for exec command failures [OK]

Common Mistakes:

• Assuming 'exit' event catches all errors
• Not adding 'error' event listener
• Confusing exec with spawn error handling

5. You want to run a child process and handle both startup errors and non-zero exit codes. Which code snippet correctly handles both cases?

hard

A. const child = spawn('mycmd');
child.on('close', (code) => console.log('Process closed with code', code));

B. const child = spawn('mycmd');
child.on('exit', (code) => {
if (code !== 0) console.error('Startup error:', code);
});

C. const child = spawn('mycmd');
child.on('error', (err) => console.log('Exit code:', err));

D. const child = spawn('mycmd');
child.on('error', (err) => console.error('Startup error:', err));
child.on('exit', (code) => {
if (code !== 0) console.log('Exit code:', code);
});

Solution

1. Step 1: Handle startup errors with 'error' event

   Listening to 'error' catches problems starting the process, like command not found.

2. Step 2: Handle non-zero exit codes with 'exit' event

   The 'exit' event provides the exit code; checking if it's not zero indicates failure.

3. Step 3: Verify option correctness

   const child = spawn('mycmd'); child.on('error', (err) => console.error('Startup error:', err)); child.on('exit', (code) => { if (code !== 0) console.log('Exit code:', code); }); listens to both 'error' and 'exit' properly and logs appropriate messages.

4. Final Answer:

   const child = spawn('mycmd'); child.on('error', (err) => console.error('Startup error:', err)); child.on('exit', (code) => { if (code !== 0) console.log('Exit code:', code); }); -> Option D

5. Quick Check:

   Use 'error' for startup, 'exit' for exit codes [OK]

Hint: Use both 'error' and 'exit' events to cover all errors [OK]

Common Mistakes:

• Ignoring 'error' event for startup failures
• Logging exit code as startup error
• Using only 'close' event without error handling