Command chaining (&&, ||, ;) in Linux CLI - Step-by-Step Execution

Concept Flow - Command chaining (&&, ||, ;)

Start

↓

Execute first command

↓

Check exit status

↓

If &&

↓

Execute next command

↓

If first failed?

↓

Skip

↓

End or next chain

This flow shows how the shell runs commands connected by &&, ||, or ; based on success or failure of previous commands.

Execution Sample

Linux CLI

echo Hello && echo World || echo Fail; echo Done

Runs 'echo Hello', then 'echo World' if first succeeds, else 'echo Fail', then always 'echo Done'.

Execution Table

Step	Command	Previous Exit Status	Condition Checked	Action Taken	Output
1	echo Hello	N/A	Run first command	Execute	Hello
2	echo World	0 (success)	&&: previous success?	Execute	World
3	echo Fail	0 (success)	||: previous failed?	Skip
4	echo Done	N/A	;: always run next	Execute	Done

💡 All commands processed; chaining rules determined which commands ran.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4
Exit Status	N/A	0	0	0	0
Command Executed	None	echo Hello	echo World	echo World (skip echo Fail)	echo Done

Key Moments - 3 Insights

Why does 'echo Fail' not run even though it is after 'echo World'?

Because 'echo World' succeeded (exit status 0), the '||' operator skips the next command if the previous succeeded, as shown in step 3 of the execution_table.

What is the difference between ';' and '&&' in chaining?

';' always runs the next command regardless of success or failure, while '&&' runs the next command only if the previous succeeded. See step 4 where 'echo Done' runs no matter what.

How does the shell decide to run the second command after '&&'?

It checks if the previous command's exit status is zero (success). If yes, it runs the next command. This is shown in step 2 where 'echo World' runs because 'echo Hello' succeeded.

Visual Quiz - 3 Questions

Look at the execution table, what is the exit status after step 1?

A 0 (success)

B 1 (failure)

C N/A

D Undefined

💡 Hint

Check the 'Previous Exit Status' column for step 2 which shows the exit status after step 1.

At which step does the shell skip a command due to chaining rules?

A Step 2

B Step 4

C Step 3

D No commands are skipped

💡 Hint

Look at the 'Action Taken' column in the execution_table to find where a command is skipped.

If the first command 'echo Hello' failed, which command would run next?

A 'echo Fail' only

B 'echo Fail' and 'echo Done'

C 'echo World' and 'echo Fail'

D 'echo World' only

💡 Hint

Consider how '&&' and '||' behave on failure, referencing the concept_flow and execution_table logic.

Concept Snapshot

Command chaining connects commands with operators:
- '&&' runs next only if previous succeeds
- '||' runs next only if previous fails
- ';' runs next always
Exit status (0=success) controls flow
Use chaining to combine commands smartly

Full Transcript

This lesson shows how Linux shell command chaining works using &&, ||, and ; operators. The shell runs the first command, then checks its exit status. If chained with &&, the next command runs only if the previous succeeded (exit status 0). If chained with ||, the next command runs only if the previous failed (non-zero exit status). The ; operator runs the next command always, regardless of previous success or failure. The example 'echo Hello && echo World || echo Fail; echo Done' runs 'echo Hello' first. Since it succeeds, 'echo World' runs next. Because 'echo World' succeeded, 'echo Fail' is skipped due to ||. Finally, 'echo Done' runs because ; always runs the next command. This chaining lets you control command flow based on success or failure, useful for scripting and command line tasks.

Practice

1. What does the command chaining operator && do in Linux shell?

easy

A. Runs the next command only if the previous command succeeded

B. Runs the next command only if the previous command failed

C. Runs all commands regardless of previous command success

D. Runs the next command in the background

Solution

1. Step 1: Understand the meaning of &&

   The && operator runs the next command only if the previous command returns success (exit status 0).

2. Step 2: Compare with other operators

   || runs next command only if previous failed, and ; runs commands regardless of success.

3. Final Answer:

   Runs the next command only if the previous command succeeded -> Option A

4. Quick Check:

   && means run next if success [OK]

Hint: Remember: && means next runs only on success [OK]

Common Mistakes:

• Confusing && with ||
• Thinking && runs commands regardless
• Assuming && runs commands in background

2. Which of the following is the correct syntax to run cmd1 and then cmd2 regardless of cmd1's success or failure?

easy

A. cmd1 && cmd2

B. cmd1 || cmd2

C. cmd1 ; cmd2

D. cmd1 & cmd2

Solution

1. Step 1: Identify the operator that runs commands regardless

   The semicolon ; runs commands one after another no matter if the first succeeds or fails.

2. Step 2: Check other options

   && runs next only if first succeeds, || runs next only if first fails, & runs command in background.

3. Final Answer:

   cmd1 ; cmd2 -> Option C

4. Quick Check:

   ; runs commands regardless [OK]

Hint: Use ; to run commands one after another always [OK]

Common Mistakes:

• Using && or || when unconditional run is needed
• Confusing & (background) with ;
• Missing spaces around operators

3. What will be the output of the following commands if file.txt does not exist?
cat file.txt && echo "File exists" || echo "File missing"

medium

A. File exists

B. File missing

C. No output

D. cat: file.txt: No such file or directory

Solution

1. Step 1: Understand command chaining behavior

   cat file.txt fails because file does not exist, so && echo "File exists" is skipped, and || echo "File missing" runs.

2. Step 2: Predict output

   The error message from cat is printed to stderr (not shown here), but the command output from chaining is File missing.

3. Final Answer:

   File missing -> Option B

4. Quick Check:

   Failed cat triggers || echo [OK]

Hint: Remember: || runs next if previous fails [OK]

Common Mistakes:

• Expecting 'File exists' output
• Ignoring that cat prints error to stderr
• Thinking no output appears

4. Identify the error in this command chaining:
mkdir newdir || echo "Created" && cd newdir

medium

A. The echo message is incorrect

B. mkdir should be followed by ; not ||

C. The chaining logic runs cd only if echo runs

D. No error, command works as intended

Solution

1. Step 1: Analyze the chaining logic

   Operators || and && have equal precedence and associate left-to-right: parsed as (mkdir newdir || echo "Created") && cd newdir.

2. Step 2: Trace execution

   mkdir success: skip echo, success && cd runs. mkdir fail: run echo "Created" (success) && cd runs. Error: echo "Created" runs only on failure (dir exists), wrong message.

3. Final Answer:

   The echo message is incorrect -> Option A

4. Quick Check:

   || echo "Created" runs on mkdir fail [OK]

Hint: || triggers echo only on failure, check message [OK]

Common Mistakes:

• Misparsing as right-associative (mkdir || (echo && cd))
• Thinking cd skips on mkdir success
• Overlooking echo on mkdir failure

5. You want to run backup.sh only if prepare.sh succeeds, but if prepare.sh fails, you want to run cleanup.sh. Which command chaining achieves this?

hard

A. prepare.sh || cleanup.sh && backup.sh

B. prepare.sh && (backup.sh || cleanup.sh)

C. prepare.sh ; backup.sh ; cleanup.sh

D. prepare.sh && backup.sh || cleanup.sh

Solution

1. Step 1: Understand the requirement

   Run backup.sh only if prepare.sh succeeds; if prepare.sh fails, run cleanup.sh.

2. Step 2: Analyze prepare.sh && backup.sh || cleanup.sh

   prepare.sh && backup.sh || cleanup.sh means: if prepare.sh succeeds, run backup.sh. If either prepare.sh or backup.sh fails, run cleanup.sh. This matches the requirement.

3. Final Answer:

   prepare.sh && backup.sh || cleanup.sh -> Option D

4. Quick Check:

   Run backup if prepare succeeds, else cleanup [OK]

Hint: Use && then || to handle success and failure paths [OK]

Common Mistakes:

• Running cleanup even if prepare succeeds
• Running backup even if prepare fails
• Using ; which ignores success/failure