exec for running shell commands in Node.js - Step-by-Step Execution

Concept Flow - exec for running shell commands

Start

↓

Call exec with command

↓

Node.js runs shell command

↓

Command executes in shell

↓

Shell returns output or error

↓

Callback receives error, stdout, stderr

↓

Process output or handle error

↓

End

This flow shows how Node.js exec runs a shell command, waits for it to finish, then returns output or error to the callback.

Execution Sample

Node.js

import { exec } from 'node:child_process';

exec('echo Hello', (error, stdout, stderr) => {
  if (error) {
    console.error(`Error: ${error.message}`);
  } else {
    console.log(`Output: ${stdout}`);
  }
});

This code runs the shell command 'echo Hello' and prints the output or error.

Execution Table

Step	Action	Command	Callback Params	Output/Effect
1	Call exec	'echo Hello'	N/A	Starts shell command execution
2	Shell runs command	'echo Hello'	N/A	Shell prints 'Hello' to stdout
3	Command finishes	'echo Hello'	error=null, stdout='Hello\n', stderr=''	Callback invoked with output
4	Callback processes	N/A	error=null, stdout='Hello\n', stderr=''	Console logs: Output: Hello
5	End	N/A	N/A	Program ends

💡 Command completes successfully, callback receives output and no error.

Variable Tracker

Variable	Start	After exec call	After command finishes	Final
error	undefined	undefined	null	null
stdout	undefined	undefined	Hello\n	Hello\n
stderr	undefined	undefined

Key Moments - 3 Insights

Why does the callback receive three parameters: error, stdout, and stderr?

Because exec runs a shell command that can produce output (stdout), errors (stderr), or execution errors (error). The callback handles all these to know what happened. See execution_table step 3.

What happens if the shell command fails?

If the command fails, the error parameter in the callback will contain details, and stdout may be empty. This lets you handle failures gracefully. See execution_table step 3 for error=null case; if error was set, you'd handle it in the callback.

Why is stdout 'Hello\n' and not just 'Hello'?

Because the shell command 'echo' adds a newline character at the end of its output. This is normal shell behavior. See execution_table step 3 and variable_tracker stdout value.

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what is the value of error passed to the callback?

A undefined

B null

C An Error object

D A string describing the error

💡 Hint

Check the 'Callback Params' column at step 3 in execution_table.

At which step does the shell command finish execution?

A Step 3

B Step 2

C Step 1

D Step 4

💡 Hint

Look for when the callback is invoked with output in execution_table.

If the command was changed to 'invalidcommand', what would change in the execution_table?

A error would be null and stdout would have output

B stderr would be empty and stdout would have error message

C error would contain an Error object and stdout would be empty

D Callback would not be called

💡 Hint

Recall how exec handles invalid commands and error parameter in callback.

Concept Snapshot

exec(command, callback) runs a shell command asynchronously.
Callback receives (error, stdout, stderr).
If error is null, command succeeded; stdout has output.
If error exists, command failed; handle error.
Use exec for simple shell commands in Node.js.

Full Transcript

This example shows how Node.js exec runs a shell command like 'echo Hello'. When exec is called, Node.js starts the shell command asynchronously. The shell runs the command and produces output or errors. When the command finishes, exec calls the callback with three parameters: error, stdout, and stderr. If the command succeeds, error is null and stdout contains the output, here 'Hello\n'. If the command fails, error contains details. The callback can then log the output or handle errors. This flow helps run shell commands from Node.js code easily.

Practice

1. What does the exec function in Node.js primarily do?

easy

A. Runs shell commands from within a Node.js program

B. Creates a new HTTP server

C. Reads files from the filesystem

D. Starts a database connection

Solution

1. Step 1: Understand the purpose of exec

   The exec function is designed to run shell commands from Node.js code.

2. Step 2: Compare with other options

   Creating servers, reading files, or database connections are unrelated to exec.

3. Final Answer:

   Runs shell commands from within a Node.js program -> Option A

4. Quick Check:

   exec runs shell commands = B [OK]

Hint: Remember exec runs shell commands, not servers or files [OK]

Common Mistakes:

• Confusing exec with file reading functions
• Thinking exec creates servers
• Assuming exec manages databases

2. Which is the correct way to import and use exec from the child_process module in Node.js?

easy

A. import exec from 'child_process';

B. const exec = require('child_process').exec;

C. const exec = require('exec');

D. import { exec } from 'child_process';

Solution

1. Step 1: Recall Node.js import syntax for exec

   In Node.js CommonJS, exec is imported as const exec = require('child_process').exec;.

2. Step 2: Check other options for correctness

   import exec from 'child_process'; uses ES module default import incorrectly; const exec = require('exec'); tries to require a non-existent module; import { exec } from 'child_process'; is ES module named import but Node.js needs special config.

3. Final Answer:

   const exec = require('child_process').exec; -> Option B

4. Quick Check:

   CommonJS import for exec = A [OK]

Hint: Use require('child_process').exec for standard Node.js [OK]

Common Mistakes:

• Using import without Node.js ES module setup
• Requiring wrong module name
• Confusing default and named imports

3. What will the following Node.js code output if the current directory contains a file named test.txt?

const { exec } = require('child_process');
exec('ls', (error, stdout, stderr) => {
  if (error) {
    console.error(`Error: ${error.message}`);
    return;
  }
  if (stderr) {
    console.error(`Stderr: ${stderr}`);
    return;
  }
  console.log(`Output: ${stdout}`);
});

medium

A. Output: test.txt

B. Error: ls command not found

C. Stderr: Permission denied

D. No output

Solution

1. Step 1: Understand exec running 'ls'

   The command ls lists files in the current directory. If test.txt exists, it will appear in the output.

2. Step 2: Analyze callback behavior

   No error or stderr means output is printed with file names, so console logs 'Output: test.txt\n'.

3. Final Answer:

   Output: test.txt -> Option A

4. Quick Check:

   exec runs ls, outputs files = A [OK]

Hint: exec callback logs stdout if no error or stderr [OK]

Common Mistakes:

• Assuming error if command runs successfully
• Ignoring stdout content
• Confusing stderr with stdout

4. Identify the error in this Node.js code using exec:

const { exec } = require('child_process');
exec('node -v', (error, stdout, stderr) => {
  if (error) {
    console.log(error);
  }
  console.log(stdout);
});

medium

A. Callback function has wrong parameters

B. Incorrect command syntax for node version

C. Missing error return causes stdout to print even on error

D. exec is not imported correctly

Solution

1. Step 1: Check error handling logic

   The code logs error but does not return or stop, so stdout logs even if error occurs.

2. Step 2: Understand impact of missing return

   This can cause confusing output mixing error and stdout, which is not ideal.

3. Final Answer:

   Missing error return causes stdout to print even on error -> Option C

4. Quick Check:

   Missing error return causes stdout to print even on error = D [OK]

Hint: Return after error to avoid printing stdout [OK]

Common Mistakes:

• Not returning after error check
• Assuming exec import is wrong
• Thinking command syntax is incorrect

5. You want to run a shell command that lists all files but only print those containing the word 'log'. Which exec usage correctly achieves this in Node.js?

hard

A. exec('ls > grep log', (err, stdout) => { if (!err) console.log(stdout); });

B. exec('ls && grep log', (err, stdout) => { if (!err) console.log(stdout); });

C. exec('ls | find log', (err, stdout) => { if (!err) console.log(stdout); });

D. exec('ls | grep log', (err, stdout) => { if (!err) console.log(stdout); });

Solution

1. Step 1: Understand shell command chaining

   The pipe | sends output of ls to grep log to filter lines containing 'log'.

2. Step 2: Evaluate each option's command

   ls | grep log correctly pipes output to grep for filtering; ls > grep log uses redirection to create a file; ls && grep log runs sequentially without piping; ls | find log pipes to filesystem search tool unsuitable for text filtering.

3. Final Answer:

   exec('ls | grep log', (err, stdout) => { if (!err) console.log(stdout); }); -> Option D

4. Quick Check:

   Pipe output to grep for filtering = C [OK]

Hint: Use pipe (|) to filter command output with grep [OK]

Common Mistakes:

• Using && instead of | for piping output
• Misusing redirection operators
• Confusing grep with find command