PS1 Environment Variable (Bash Prompt)

1. What is PS1?

PS1 stands for Prompt String 1.

It defines how your primary shell prompt looks — the text you see before you type a command.

Example of a prompt:

aisalkyn@macbook:~/Desktop$

Everything before $ is controlled by PS1.

2. Simple PS1 Change (Basic Example)

You can change PS1 temporarily:

PS1="hello-bash "

Result:

hello-bash ls

This proves:

• PS1 is printed before every command
  


• It is just text, unless we add placeholders

3. Why End PS1 with $?

Best practice:

PS1="hello-bash$ "

Why?

• 
  $ visually separates prompt from command
  


• Easier to read


• Standard across Unix/Linux systems

4. Using Placeholders (Escape Sequences)

PS1 supports special placeholders that get replaced dynamically.

Common Placeholders

5. Example: Username + Hostname

PS1="\u@\H "

Output:

[email protected]

6. Showing Current Directory

Full path

PS1="\w$ "

Example:

/Users/aisalkyn/Desktop$

Only last directory

PS1="\W$ "

Example:

Desktop$

7. Adding Time

PS1="\t \@ \W$ "

Example:

17:45 05:45 PM Desktop$

8. Most Common Production Prompt

This is very common in real environments:

PS1="\u@\h:\w\$ "

Example:

aisalkyn@macbook:/Users/aisalkyn/Desktop$

9. Customizing for Personal Use

If you already know:

• your username


• your machine name

You might prefer a minimal prompt:

PS1="\W$ "

Example:

Desktop$

This is clean and efficient.

10. Why PS1 Resets When Opening a New Shell

When you open a new terminal:

• Bash reloads startup configuration
  


• Temporary environment variables are lost


• 
  PS1 gets reset

That’s why changes disappear.

11. Making PS1 Persistent (Permanent)

You must put it in a bash startup file.

Edit .bashrc

nano ~/.bashrc

Add at the bottom:

PS1="\W$ "

Save and exit.

Now:

• Every new shell uses this prompt


• No need to retype it

12. Why This Is Useful in Real Work

Benefits:

• Always know where you are
  


• Less need for pwd
  


• Faster navigation


• Cleaner workflow


• Very helpful on servers and EC2 instances

How Color Works in the Terminal (History → Theory → Practice)

This history explains:

• why colors work the way they do,


• why escape sequences exist,


• why modern terminals behave the way they do today.

2. Physical Terminals (Before Modern Displays)

In the late 1970s and early 1980s, computers did not work like today.

A famous example is the VT100 terminal (produced around 1978–1983).

Important characteristics:

• It was a physical device (screen + keyboard).


• It was not a computer.


• It was not connected via HDMI or video cable.

Instead:

• The computer sent text instructions to the terminal.


• 
  

  The terminal itself:

  
  
  
  
  
  • moved the cursor,
  
  
  • drew characters,
  
  
  • applied colors or styles.
  
  
  
  
  
  

Example (conceptually):

“Move cursor to row 5, column 10 and print text in green.”

The terminal executed these instructions and displayed the result.

3. ASCII and Text-Based Output

These terminals relied on ASCII encoding:

• 128 characters


• Letters, numbers, punctuation, control characters


• Enough for English text

Everything on screen was text, not pixels.

4. Terminal Emulators (Today)

Modern systems no longer use physical terminals.

Instead, we use terminal emulator applications:

• Terminal.app


• iTerm2


• GNOME Terminal


• Windows Terminal

They are called emulators because they:

• emulate old hardware terminals (like VT100),


• still understand the same command-based instructions.

This is why:

• terminals today still behave like text devices,


• escape sequences still exist.

5. Why This History Still Matters

Even today:

• terminals have capabilities
  


• some support colors, bold, underline, blinking, etc.


• others support fewer features

To communicate these capabilities, Unix systems use the environment variable:

TERM

6. The TERM Environment Variable

TERM tells programs what kind of terminal is being used.

Example:

echo $TERM

Typical output:

xterm-256color

Meaning:

• xterm-compatible


• supports 256 colors
  

Most modern terminals use this value.

7. Why Programs Check $TERM

Programs like:

• ls


• vim


• less


• grep

check $TERM before:

• outputting color,


• using special formatting.

If a terminal does not support color, programs avoid sending color codes.

8. Listing All Known Terminal Types

Terminal capabilities are stored in the terminfo database.

To list them:

toe

If nothing appears:

toe -a

This lists all terminal definitions available on your system.

9. Example: VT100 Still Exists

You can search for VT100:

toe -a | grep vt100

Even today:

• systems know how to talk to VT100


• the protocol is still supported

This shows how backward-compatible terminals are.

10. How the Shell Controls the Terminal

The shell does not draw pixels.

Instead, it sends escape sequences:

• instructions that start with a special character,


• telling the terminal how to render text.

11. Escape Sequences (Core Concept)

An escape sequence:

• starts with the ESC character
  


• followed by instructions

In bash, ESC is written as:

\e

To enable escape interpretation in echo, use:

echo -e

12. Simple Example: New Line

echo -e "Hello\nBash"

Output:

Hello

Bash

\n is interpreted because of -e.

13. Color Escape Sequence Structure

General format:

\e[<codes>m

Example:

echo -e "\e[30;40m"

Explanation:

• 
  \e → escape


• 
  [ → control sequence start


• 
  30 → foreground color


• 
  40 → background color


• 
  m → apply to text

14. Example: Black on Black (Not Usable)

echo -e "\e[30;40m"

Result:

• black text


• black background


• terminal becomes unreadable

This shows:

• escape sequences change terminal state
  


• the state persists until reset

15. Example: Cyan Text on Red Background

echo -e "\e[36;41m"

Result:

• cyan foreground


• red background

Not pretty, but useful for demonstration.

16. Common Color Codes

Note: terminals may adjust colors based on themes.

17. More Than 8 Colors

With xterm-256color:

• terminals support 256 colors
  


• even full RGB in some cases

But:

• most real-world prompts use basic colors


• simplicity = compatibility

18. Terminal Capabilities via infocmp

To see what your terminal claims to support:

infocmp

This:

• reads $TERM
  


• lists supported features


• shows escape sequences

Example capabilities:

• bold


• underline


• clear screen


• colors

19. Bold Text Example

Start bold:

echo -e "\e[1mBold Text"

But notice:

• bold stays enabled


• prompt and next commands remain bold

20. Resetting Terminal Formatting

To reset everything:

echo -e "\e[0m"

This is called SGR reset.

Always reset after formatting.

21. Combining Formatting Safely

echo -e "\e[1mBold\e[0m Normal"

Result:

• “Bold” → bold


• “Normal” → default formatting

22. Problem with Raw Escape Sequences

Issues:

• hard to remember


• unreadable


• error-prone


• not portable

Example:

\e[1;36;41m

Not human-friendly.

23. Solution: tput

Terminal capabilities have names (from infocmp).

Example:

• bold


• sgr0


• setaf


• setab

Wouldn’t it be nice to use names instead of codes?

That’s exactly what tput does.

Command Substitution, tput, and PS1 Pitfalls (Very Important)

Part 1 — Command Substitution (Quick Crash Course)

What is Command Substitution?

Command substitution allows you to:

• execute a command


• capture its output


• insert that output inside another command

Syntax (Modern, Recommended)

$(command)

Example:

echo "This is the output: $(ls)"

Result:

• 
  ls runs


• its output is captured


• the result is inserted into the string

Why Use Double Quotes?

Always wrap command substitution in double quotes:

echo "Files: $(ls)"

This prevents Bash from:

• word splitting


• glob expansion


• unwanted rewriting of the output

This becomes critical later when we use tput.

Why ls Output Changes Format

You observed this correctly.

Direct terminal output:

ls

→ multiple columns

Captured output:

echo "$(ls)"

→ one entry per line

Why?

Because ls checks:

• “Am I printing directly to a terminal?”


• If no (pipe, redirect, substitution), it switches to line mode

Same behavior with pipes:

ls | cat

Using Escape Characters with echo

To insert special characters (like newlines):

echo -e "Output:\n$(ls)"

Without -e, escape characters like \n are ignored.

Why Command Substitution Matters Here

Because:

• 
  tput prints escape sequences
  


• command substitution lets us embed those sequences cleanly
  


• we can generate formatting dynamically

This leads us to tput.

Part 2 — tput: Human-Readable Terminal Control

Why tput Exists

Typing raw escape sequences is:

• unreadable


• hard to remember


• error-prone

tput converts terminfo capability names into correct escape sequences for your terminal.

Common tput Commands

Clear Screen

tput clear

Same effect as:

clear

Cursor Position

tput cup 5 20

Moves cursor to:

• row 5


• column 20

Used for:

• interactive UIs


• dashboards


• terminal animations

Text Formatting with tput

Bold Text

tput bold

Underline Text

tput smul

Reset Everything (Very Important)

tput sgr0

Without reset:

• formatting persists


• prompt and commands stay bold/colored

Colors with tput

Foreground Color

tput setaf <number>

Background Color

tput setab <number>

Common Color Numbers

Example:

tput setaf 4   # blue text

tput setab 3   # yellow background

Querying Terminal Capabilities (Real Values)

Unlike infocmp, tput gives live values.

Number of Lines

tput lines

Number of Columns

tput cols

Number of Colors

tput colors

These values change dynamically if you resize or zoom your terminal.

Part 3 — The Critical PS1 Escape Sequence Problem

The Problem

Bash must know:

• how long your prompt is


• where line wrapping occurs


• where the cursor should move

But:

• escape sequences do not print visible characters


• Bash still counts them unless told not to
  

This causes:

• broken line wrapping


• cursor jumps


• impossible editing of long commands


• extremely annoying behavior

What Goes Wrong (Symptoms)

When escape sequences are not handled correctly:

• lines wrap too early


• cursor moves to wrong positions


• backspace behaves incorrectly


• multi-line commands break visually

You demonstrated this perfectly.

The Solution: \[ \] (Mandatory for PS1)

Bash provides a fix.

Rule (Very Important)

Wrap every non-printing escape sequence in:

\[

\]

This tells Bash:

“These characters do NOT take screen space. Do not count them.”

Correct PS1 Example (With Colors)

PS1="\[$(tput setaf 4)\]\W\[$(tput sgr0)\]$ "

Explanation:

• 
  \[ … \] → invisible characters


• 
  tput setaf 4 → blue text


• 
  \W → current directory


• 
  tput sgr0 → reset formatting

What You Must Never Do

❌ Do NOT include visible characters inside \[ \]

❌ Do NOT include spaces inside \[ \]

❌ Do NOT forget to reset formatting

Bad example:

\[$(tput sgr0) \]

That space breaks alignment.

Correct Pattern to Follow

\[ escape-sequence \] visible-text \[ reset \]

Why This Matters in Real Life

Incorrect PS1 formatting leads to:

• unusable shells


• broken SSH sessions


• confusion during incidents


• frustration during interviews

Correct PS1 formatting:

• looks professional


• behaves correctly


• works on servers


• is production-safe

Exercise — Create a Custom PS1 Prompt (Using tput)

• Bash placeholders (\W, \t, etc.)


• 
  tput for colors and formatting


• Proper escaping so multiline editing works correctly

This is exactly how real Linux / DevOps engineers customize their shell.

🎯 Goal of the Exercise

Create a PS1 prompt that:

• Shows the current directory
  


• Shows the current time
  


• Uses colors
  


• Optionally uses bold text
  


• Ends cleanly so typed commands appear normal


• Works correctly with long and multiline commands
  

📌 Rules You Must Follow (Very Important)

1. Use double quotes when assigning PS1

Correct:

PS1="..."

Incorrect:

PS1='...'   # breaks command substitution

Why?

• 
  $() only works inside double quotes
  

2. Command substitution runs only once

Example (❌ bad idea):

PS1="$(ls)"

This:

• runs ls once


• freezes the output forever


• does NOT update when you change directories

✅ Use placeholders (\W, \u, \h) for dynamic values

✅ Use tput for formatting (its output is constant)

3. Escape visible $ characters

If you want a literal $ in PS1:

\$

Otherwise Bash treats it as a variable.

4. Unicode is allowed (optional)

You may use:

• arrows (➜)


• symbols


• emojis

Only if:

• your terminal supports Unicode


• they display correctly

5. ALWAYS reset formatting at the end

If you don’t:

• your typed commands stay colored or bold


• terminal becomes annoying

Use:

$(tput sgr0)

⚠️ The Most Important Rule (PS1 Bug Fix)

Non-printing characters must be wrapped

Every tput output must be wrapped like this:

\[$(tput setaf 2)\]

Why?

• Bash must know which characters do not take space
  


• otherwise cursor movement and line wrapping break

❌ Never put visible characters inside \[ \]

❌ Never put spaces inside \[ \]

✅ Step-by-Step Sample Solution

Below is a clean, stable, professional PS1.

What it shows:

• green arrow


• yellow time


• cyan bold current directory


• normal text for commands

Final PS1 (Recommended Solution)

PS1="\[$(tput setaf 2)\]➜ \

\[$(tput setaf 3)\]\t \

\[$(tput setaf 6)$(tput bold)\]\W \

\[$(tput sgr0)\]\$ "

🧠 How This Works (Explained)

🧪 Result Example

➜ 14:32 Desktop $

• Cursor movement works


• Line wrapping works


• Editing long commands works


• Looks clean and professional

💾 Make It Permanent

Save it to your ~/.bashrc:

nano ~/.bashrc

Add at the bottom:

PS1="..."

Reload:

source ~/.bashrc

You now understand:

• Command substitution ($())


• 
  tput for terminal capabilities


• Why PS1 breaks without \[ \]
  


• How to build a production-safe prompt
  

This knowledge is interview-level Linux and real-world DevOps.

Shell Expansions — Filename Expansion & Tilde Expansion

1. What Is a Shell Expansion?

A shell expansion means:

Before Bash executes a command, it rewrites and expands parts of that command.

So the execution flow looks like this:

1. You type a command


2. Bash parses and expands it


3. Bash executes the rewritten command

This expansion happens before the command runs.

It may feel like “magic”, but in this chapter we are explicitly uncovering what Bash does behind the scenes.

2. Filename Expansion (Globbing)

The first expansion we look at is filename expansion, also called globbing.

The * (asterisk)

The * character means:

• match zero or more characters
  


• match file and directory names
  

Example:

ls *

What happens internally:

• Bash looks at the current directory
  


• Replaces * with all filenames
  


• Executes ls with those filenames as arguments

3. Proof That Bash Rewrites the Command

Imagine this directory contains only folders, with no spaces in their names.

When you run:

ls *

Bash effectively rewrites it to:

ls Desktop Documents Downloads Pictures Videos

That rewritten command is then executed.

4. Expansion Works With Any Command

Filename expansion is not specific to ls.

Example:

echo *

Result:

• prints all filenames in the directory

Because:

• Bash expands *
  


• then passes the expanded list to echo
  

This proves:

Filename expansion is done by Bash, not by the command.

5. Filtering With Wildcards

Match Files by Extension

ls *.txt

Meaning:

• match all filenames ending in .txt
  

If the directory contains:

a.txt

b.txt

test.txt

world.txt

All will be matched.

The ? (question mark)

The ? wildcard matches exactly one character.

Example:

ls ?.txt

Matches:

a.txt

b.txt

Does NOT match:

test.txt

world.txt

6. Filename Expansion With Paths

Filename expansion also works with paths.

Example:

echo ~/Documents/*.txt

What Bash does:

1. Expands ~ (tilde expansion)


2. Expands *.txt
   


3. Passes full paths to echo
   

You can confirm this by running:

ls ~/Documents/*.txt

Or by manually typing the expanded paths — the result is the same.

7. Why This Is Powerful

Filename expansion allows you to:

• avoid typing long filenames


• work efficiently with groups of files


• combine expansions with any command

This is one of the most used Bash features in real systems.

8. Tilde Expansion (~)

Now let’s look at tilde expansion.

The tilde (~) expands to the value of the HOME environment variable.

Normally:

~ → /home/username

9. Basic Tilde Expansion Example

ls ~

Lists:

• your home directory

This is equivalent to:

ls $HOME

10. Demonstrating That It Uses $HOME

We can prove this by echoing it:

echo ~

echo $HOME

Both produce the same output.

11. Changing $HOME (Demonstration Only)

If you override the variable:

HOME=/

Now:

ls ~

Lists:

• the root directory

⚠️ This is not recommended in practice

It’s only used here to demonstrate how tilde expansion works.

12. Confirming Expansion With echo

Because expansion happens before execution:

echo ~

Shows:

• the expanded path


• not the literal ~
  

This confirms Bash rewrites the command first.

13. Tilde Expansion With Paths

Tilde expansion also works as part of a path:

ls ~/Documents

Meaning:

ls /home/username/Documents

The tilde starts the expansion, and the rest is appended to the path.

14. ~+ — Current Working Directory

Another useful tilde form:

~+

Expands to:

• the current working directory


• same as $PWD
  

Example:

echo ~+

Equivalent to:

echo $PWD

15. Keyboard Note (Important Practical Tip)

On some systems:

• typing ~+ directly may create a composed character

Solution:

• type ~
  


• press space
  


• then type +
  

This avoids Unicode composition issues.

16. Summary

You learned:

Filename Expansion

• 
  * → zero or more characters


• 
  ? → exactly one character


• done by Bash, not commands


• works with any command

Tilde Expansion

• 
  ~ → $HOME
  


• 
  ~/path → home subdirectory


• 
  ~+ → $PWD
  

Key Rule

Expansions always happen before execution

Shell Expansions with Variables

Variable Expansion, Parameter Expansion & Word Splitting

1. Variable Expansion — The Basics

What is Variable Expansion?

Variable expansion means:

Bash replaces a variable reference with its value before executing the command.

This happens during the expansion phase, not during command execution.

2. Syntax of Variable Expansion

All variable expansions start with a dollar sign ($).

Common forms:

$VAR

${VAR}

"$VAR"

"${VAR}"

✅ Recommended best practice:

"${VAR}"

Why?

• Clearly defines where the variable name ends


• Works safely with concatenation


• Avoids ambiguity

3. The Dollar Sign Does NOT Belong to the Variable

This is a very important concept.

In Bash:

• The variable name is HOME
  


• NOT $HOME
  

The $ means:

“Perform an expansion here”

Example:

env | grep HOME

You will see:

HOME=/home/username

No dollar sign exists in the variable name itself.

4. Why Curly Braces Matter

Consider this example:

echo "$HOMEpath"

Bash looks for:

• variable named HOMEpath
  

Instead of:

echo "${HOME}path"

Which correctly expands:

/home/usernamepath

👉 Curly braces explicitly mark where the variable name ends.

5. Expansion Happens Before Execution

Example:

echo "${HOME}"

What really happens internally:

echo /home/username

The echo command never knows a variable existed.

6. Shell Parameter Expansion (Working with Strings)

Shell parameter expansion allows us to manipulate variable contents.

This only works on existing variables.

6.1 String Length

echo "${#PATH}"

• Returns the number of bytes in the string


• Usually equals character count (ASCII)


• May differ for multi-byte Unicode characters

6.2 Substring Extraction

echo "${PATH:4:10}"

Meaning:

• Start at index 4
  


• Extract 10 characters

Indexes start at 0.

6.3 String Replacement (Single Match)

echo "${HOME/home/Users}"

Replaces:

• first occurrence of home
  


• with Users
  

6.4 Replace All Occurrences

echo "${PATH//:/ }"

• Replaces all colons with spaces


• Useful for transforming lists

6.5 Expansion Does NOT Modify the Variable

This:

echo "${HOME/home/Users}"

❌ does NOT change $HOME

To modify it, you must assign it explicitly:

HOME="${HOME/home/Users}"

⚠️ No spaces allowed around =.

7. Variable Expansion vs Assignment (Critical Difference)

8. Word Splitting — What Happens After Expansion

After all expansions, Bash performs word splitting.

Word splitting means:

Bash breaks the command into words (arguments).

Example:

touch a.txt b.txt

Split into:

1. 
   touch (command)


2. 
   a.txt (argument 1)


3. 
   b.txt (argument 2)

9. The IFS Variable

Word splitting happens on characters defined in $IFS.

Default IFS contains:

• space


• tab


• newline

You can inspect it:

echo "${IFS}"

It may look empty — but it is not.

10. Consecutive Delimiters Are Collapsed

Example:

touch    c.txt

Multiple spaces are treated as one delimiter.

Result:

c.txt

11. Disabling Word Splitting with Quotes

Quotes prevent word splitting.

Example without quotes:

touch a file.txt

Creates:

• a


• file.txt

With Quotes (Correct)

touch "a file.txt"

Creates:

• a file.txt

Quotes are not part of the filename.

12. Single Quotes vs Double Quotes (Preview)

Both:

• disable word splitting

But:

• 
  single quotes disable expansions


• 
  double quotes allow expansions

Examples:

echo '$HOME'

echo "$HOME"

Output:

$HOME

/home/username

13. Quotes Allow Whitespace in Filenames

touch "a file.txt b.txt"

Creates one file with spaces in its name.

Without quotes:

touch a file.txt b.txt

Creates three files.

14. Why Quotes Are Essential in Bash

Quotes:

• prevent word splitting


• preserve whitespace


• control expansions


• prevent bugs in scripts


• are required for safe variable usage

This is one of the most important Bash concepts.

15. Summary

You learned:

Variable Expansion

• 
  $VAR, ${VAR}
  


• expansion happens before execution


• 
  $ triggers expansion, not part of variable name

Parameter Expansion

• string length


• substrings


• replacements

Word Splitting

• happens after expansion


• controlled by IFS
  


• disabled by quotes

Quotes, Expansions, and Their Hidden Dangers in Bash

Before we go deeper, here is an important mindset shift.

In Bash, the more you know about other programming languages, the more confusing quoting becomes.

1. The Bash Execution Pipeline (Repeat — Very Important)

Every Bash command follows the same order:

1. 
   Expansions (depending on quotes)


2. Word splitting


3. Quote removal


4. Command execution

Quotes affect only steps 1 and 2.

After that, quotes disappear.

2. Three Commands — Three Completely Different Meanings

Let’s analyze this pattern:

echo $PWD/*.txt

echo '$PWD/*.txt'

echo "$PWD/*.txt"

Case 1 — No Quotes

echo $PWD/*.txt

What happens:

• Variable expansion ✅ ($PWD)


• Filename expansion ✅ (*.txt)


• Word splitting ✅

Bash rewrites it to something like:

echo /home/user/docs/a.txt /home/user/docs/b.txt

Then echo runs.

Case 2 — Single Quotes (Most Restrictive)

echo '$PWD/*.txt'

What happens:

• Variable expansion ❌


• Filename expansion ❌


• Word splitting ❌

Bash passes the text literally:

$PWD/*.txt

Single quotes mean:

“Do NOT touch anything inside.”

Case 3 — Double Quotes (Selective Expansion)

echo "$PWD/*.txt"

What happens:

• Variable expansion ✅


• Filename expansion ❌


• Word splitting ❌

Result:

/home/user/docs/*.txt

The * is now just a character, not a wildcard.

3. Quotes Do NOT Create Strings

This is a key Bash concept.

Quotes:

• do not create string objects


• do not exist at execution time


• only control parsing rules

Example:

echo "Hello" "World"

Bash rewrites this to:

echo Hello World

Quotes are removed before execution.

4. Quotes Can Wrap Any Part of a Command

These are all valid:

echo "Hello World"

"echo" Hello World

e"c"ho Hello World

Why?

• Quotes are removed before execution


• Bash only cares about the final rewritten command

5. Quotes Can Break Commands

Example:

"echo Hello"

Why this fails:

• Word splitting is disabled


• Bash treats this as one word
  


• Bash looks for a program literally named:
  

  echo Hello

Which doesn’t exist.

6. Filename Expansion Can Create Commands (Dangerous!)

Consider this directory:

echo

a.txt

b.txt

Now run:

*

What Bash sees:

echo a.txt b.txt

This becomes:

• command: echo
  


• arguments: a.txt b.txt
  

So Bash executes echo.

This is not a bug — it is a consequence of expansion order.

7. Filenames Starting With - (Very Dangerous)

Create this file:

touch ./-al

Now run:

ls *

Bash expands to:

ls -al a.txt b.txt

Result:

• 
  -al is treated as an option
  


• output format changes unexpectedly

8. How to Protect Against This

Rule: Prefix filenames with ./

ls ./*

Now expansion becomes:

ls ./-al ./a.txt ./b.txt

Why this works:

• arguments no longer start with -
  


• cannot be interpreted as options

This is a critical defensive habit.

9. Variables + Word Splitting = Bugs

Consider this directory:

"My Folder"

Now:

touch $PWD/file.txt

Bash rewrites it to:

touch /home/user/My Folder/file.txt

Then word splitting happens:

touch /home/user/My Folder/file.txt

Which becomes:

• /home/user/My


• Folder/file.txt

❌ Wrong.

Correct Way

touch "${PWD}/file.txt"

Why this works:

• Variable expands


• Word splitting disabled


• Path stays intact

10. Why We Always Use "${VAR}"

Best practice:

"${VAR}"

Benefits:

• safe expansion


• no word splitting


• clear variable boundaries


• works with spaces


• works with concatenation

11. Best Practices Summary (Very Important)

File Paths

• Prefer:
  

  ./file.txt

• 
  

  Especially when:

  
  
  
  
  
  • filenames are unknown
  
  
  • filenames start with -
    
  
  
  • filenames come from variables
  
  
  
  
  
  

Quotes

Use the most restrictive quoting possible:

1. 
   Single quotes – safest
   

   'literal text'

1. 
   Double quotes – when expansion is needed
   

   "${VAR}"

1. 
   No quotes – only when you explicitly want:

• filename expansion


• word splitting

Variables

Always:

"${VAR}"

Never:

$VAR

Unless you fully understand the consequences.

12. Final Mental Model

• Quotes do not create strings
  


• Quotes control expansion and splitting
  


• Expansions are powerful but dangerous


• 
  

  Defensive Bash means:

  
  
  
  
  
  • quoting carefully
  
  
  • prefixing paths
  
  
  • assuming filenames are hostile
  
  
  
  
  
  

As always, remember the key principle:

Bash rewrites your command before execution.

Escaping and brace expansion control how that rewrite happens.

Part 1 — What Is Escaping?

What Does Escaping Mean?

Escaping means:

Disable the special meaning of the next character only.

In Bash, escaping is done using the backslash:

\

The backslash tells Bash:

“Treat the next character literally.”

2. Escaping Whitespace (Very Common Use Case)

Whitespace normally causes word splitting.

Example without escaping:

cd a folder

Bash sees:

• cd


• a


• folder

❌ Wrong — two arguments instead of one.

Escaping the Space

cd a\ folder

Now Bash sees:

• cd


• a folder

✅ Correct — one argument

Autocompletion Does This Automatically

If you press Tab on a path containing spaces, Bash may generate:

a\ folder

This is Bash escaping the space for you.

Important: Use a Backslash (\), Not a Forward Slash (/)

Correct:

a\ folder

Incorrect:

a/ folder

The backslash is the escape character.

3. Escaping Double Quotes

Double quotes normally:

• start a quoted region


• change expansion rules

To print a literal double quote inside double quotes:

echo "\""

Explanation:

• 
  \" disables the special meaning of "
  

Output:

"

Alternative (Simpler) Method

Use single quotes:

echo '"'

Since:

• single quotes disable all expansions
  


• the double quote inside has no special meaning

4. Why Escaping Does NOT Work Inside Single Quotes

This is one of the most confusing Bash rules, so let’s be very clear.

Inside single quotes:

• nothing is escaped


• backslashes lose their power

Example:

echo '\''

❌ This does not work.

Why?

• Single quotes disable all expansions
  


• The backslash is treated as a literal character


• Bash sees an unterminated single-quoted string

5. How to Print a Single Quote Correctly

Method 1 — Exit and Re-enter Single Quotes (Recommended)

echo '\'' 

How Bash sees it:

• 
  ' → start single quotes


• 
  \' → escaped single quote (outside)


• 
  ' → end single quotes

Method 2 — Mix Quote Types

echo "'" 

Explanation:

• double quotes allow literal single quotes


• simple and readable

Key Rule to Remember

Backslash does NOT work inside single quotes

This is by design in Bash.

6. What Escaping Really Does (Mental Model)

Escaping:

• affects only the next character
  


• disables its special meaning


• does NOT create strings


• does NOT persist

Example:

\*

Means:

• literal *
  


• no filename expansion

Part 2 — Brace Expansion

Brace expansion is a pure text generator.

It happens:

• very early


• before variable expansion


• before filename expansion


• before word splitting

7. Basic Brace Expansion

echo data.{csv,txt}

Expands to:

data.csv data.txt

Bash rewrites this before executing echo.

8. Brace Expansion with Ranges

Alphabet Range

echo {a..z}

Output:

a b c d ... z

Create Files Quickly

touch file_{1..5}.txt

Creates:

file_1.txt

file_2.txt

file_3.txt

file_4.txt

file_5.txt

Uppercase Alphabet Example

touch {A..Z}.txt

Creates:

• A.txt


• B.txt


• …


• Z.txt

9. Brace Expansion Does NOT Work Inside Quotes

These do NOT expand:

echo "{a,b}"

echo '{a,b}'

Output:

{a,b}

Correct Usage

Brace expansion must be outside quotes:

echo {a,b}".txt"

This works because:

• braces expand first


• quotes only apply to .txt
  

10. Bash Version Note (Important for macOS)

Brace expansion requires Bash 4+.

• Linux → usually Bash 4+


• macOS → ships with Bash 3.x by default

If brace expansion doesn’t work on macOS:

• it’s not your fault


• it’s a version limitation

11. Summary — Key Rules to Remember

Escaping

• Backslash escapes one character
  


• Disables special meaning


• Does not work inside single quotes

Quotes

• Single quotes: disable everything


• Double quotes: allow variable expansion


• Quotes are removed before execution

Brace Expansion

• Generates text combinations


• Happens very early


• Does NOT work inside quotes

12. When to Use Brace Expansion

Use brace expansion when:

• creating many files


• generating predictable patterns


• avoiding repetitive typing

Example:

touch report_{draft,final,backup}.txt

Command Substitution & Process Substitution in Bash

What Is Command Substitution?

Command substitution means:

Execute a command, capture its output, and replace the expansion with that output.

Syntax (Recommended)

$(command)