Bash: Display Text

echo "Hello, World!"

What this does: The computer prints “Hello, World!” to the screen.

Breaking it down:

• echo = the command to display text
• “Hello, World!” = the text to display

PowerShell: Display Text

Write-Host "Hello, World!"

What this does: Same thing—displays “Hello, World!”

Breaking it down:

• Write-Host = command to write to screen
• “Hello, World!” = the text to display

Show Current Location

Bash:

pwd

PowerShell:

Get-Location

What it does: Shows which folder you’re currently in (like checking “You Are Here” on a mall map)

Output example: /home/username or C:\Users\username

List Files in Current Folder

Bash:

ls

PowerShell:

Get-ChildItem

What it does: Shows all files and folders where you are (like opening a drawer and seeing what’s inside)

You’ll see: Names of files and folders in that location

Change to a Different Folder

Bash:

cd Documents

PowerShell:

Set-Location Documents

What it does: Moves you into the Documents folder (like walking into a different room in your house)

Pro tip: Type cd .. to go back to the parent folder (like walking out of a room)

Bash: Create and Use a Variable

name="Alice"
echo "Hello, $name!"

Output: Hello, Alice!

Breaking it down:

• name=”Alice” → Put “Alice” in a box labeled “name”
• $name → Look in the box and use what’s inside
• ⚠️ Notice: No spaces around the = sign!

PowerShell: Create and Use a Variable

$name = "Alice"
Write-Host "Hello, $name!"

Output: Hello, Alice!

Breaking it down:

• $name = “Alice” → Create a variable
• Notice the $ before the name—that’s how PowerShell knows it’s a variable
• Spaces around = are fine in PowerShell!

Storing Numbers and Doing Math

Bash:

age=25
next_year=$((age + 1))
echo "Next year I'll be $next_year"

PowerShell:

$age = 25
$nextYear = $age + 1
Write-Host "Next year I'll be $nextYear"

Output: Next year I’ll be 26

What’s happening: We’re doing math! The computer calculates 25 + 1 and stores the result.

Combining Text (Concatenation)

Bash:

first_name="John"
last_name="Smith"
full_name="$first_name $last_name"
echo "Welcome, $full_name!"

PowerShell:

$firstName = "John"
$lastName = "Smith"
$fullName = "$firstName $lastName"
Write-Host "Welcome, $fullName!"

Output: Welcome, John Smith!

What’s happening: We’re gluing text together like building with LEGO blocks!

Real-World Example: File Backup

Bash:

today=$(date +%Y-%m-%d)
filename="backup_$today.tar.gz"
echo "Creating: $filename"

PowerShell:

$today = Get-Date -Format "yyyy-MM-dd"
$filename = "backup_$today.zip"
Write-Host "Creating: $filename"

Output: Creating: backup_2025-10-13.zip

Why this is useful: Every day, your backup file has a different name with the date! No more overwriting yesterday’s backup.

Bash: Ask for Input

echo "What is your name?"
read name
echo "Hello, $name!"

What happens:

1. Script asks the question
2. Cursor blinks, waiting for you to type
3. You type your name and press Enter
4. Script greets you!

Key command: read gets input and stores it in a variable

PowerShell: Ask for Input

$name = Read-Host "What is your name?"
Write-Host "Hello, $name!"

What happens:

1. Script displays the question
2. Waits for your input
3. Stores your answer in $name
4. Uses it in the greeting

Key command: Read-Host asks and stores in one step!

Colorful Output (PowerShell)

Write-Host "Success!" -ForegroundColor Green
Write-Host "Warning!" -ForegroundColor Yellow
Write-Host "Error!" -ForegroundColor Red

Why it’s useful: Colors help users quickly understand if something worked or failed!

Colors available: Black, Blue, Cyan, Gray, Green, Magenta, Red, White, Yellow

Writing to a File Instead of Screen

Bash:

echo "Log entry: Process started" > log.txt
echo "Log entry: Task completed" >> log.txt

PowerShell:

"Log entry: Process started" | Out-File log.txt
"Log entry: Task completed" | Out-File log.txt -Append

What’s happening:

• > or Out-File creates/overwrites the file
• >> or -Append adds to the end without deleting what’s there

Real-World: User Registration Script

Bash:

echo "=== User Registration ==="
read -p "Enter your username: " username
read -p "Enter your email: " email
read -sp "Enter your password: " password
echo ""
echo "Registration complete for $username"
echo "$username registered on $(date)" >> users.log

PowerShell:

Write-Host "=== User Registration ===" -ForegroundColor Cyan
$username = Read-Host "Enter your username"
$email = Read-Host "Enter your email"
$password = Read-Host "Enter your password" -AsSecureString
Write-Host "Registration complete for $username" -ForegroundColor Green
"$username registered on $(Get-Date)" | Out-File users.log -Append

Cool features:

• read -sp (Bash) hides password as you type
• -AsSecureString (PowerShell) secures the password
• Logs each registration with a timestamp

Bash: Basic If-Statement

age=18

if [ $age -ge 18 ]; then
    echo "You can vote!"
else
    echo "Too young to vote"
fi

Breaking it down:

• if [ condition ] = check if something is true
• then = do this if true
• else = otherwise, do this
• fi = end of if-statement (“if” backwards!)

Comparison operators:

• -eq = equal to
• -ne = not equal
• -gt = greater than
• -ge = greater than or equal
• -lt = less than
• -le = less than or equal

PowerShell: Basic If-Statement

$age = 18

if ($age -ge 18) {
    Write-Host "You can vote!" -ForegroundColor Green
}
else {
    Write-Host "Too young to vote" -ForegroundColor Yellow
}

Breaking it down:

• if (condition) = check if true
• { } = curly braces contain the code to run
• else { } = what to do otherwise

Comparison operators:

• -eq = equal to
• -ne = not equal
• -gt = greater than
• -ge = greater than or equal
• -lt = less than
• -le = less than or equal

Grade Calculator

Bash:

score=85

if [ $score -ge 90 ]; then
    echo "Grade: A - Excellent!"
elif [ $score -ge 80 ]; then
    echo "Grade: B - Good job!"
elif [ $score -ge 70 ]; then
    echo "Grade: C - Average"
elif [ $score -ge 60 ]; then
    echo "Grade: D - Needs improvement"
else
    echo "Grade: F - Failed"
fi

PowerShell:

$score = 85

if ($score -ge 90) {
    Write-Host "Grade: A - Excellent!" -ForegroundColor Green
}
elseif ($score -ge 80) {
    Write-Host "Grade: B - Good job!" -ForegroundColor Cyan
}
elseif ($score -ge 70) {
    Write-Host "Grade: C - Average" -ForegroundColor Yellow
}
elseif ($score -ge 60) {
    Write-Host "Grade: D - Needs improvement" -ForegroundColor DarkYellow
}
else {
    Write-Host "Grade: F - Failed" -ForegroundColor Red
}

How it works: Script checks each condition in order until one is true, then stops.

Checking If Files Exist

Bash:

filename="data.txt"

if [ -f "$filename" ]; then
    echo "File exists! Reading..."
    cat "$filename"
else
    echo "File not found! Creating..."
    echo "Sample data" > "$filename"
fi

PowerShell:

$filename = "data.txt"

if (Test-Path $filename) {
    Write-Host "File exists! Reading..."
    Get-Content $filename
}
else {
    Write-Host "File not found! Creating..."
    "Sample data" | Out-File $filename
}

Why this is powerful: Script adapts to what it finds! If the file exists, it reads it. If not, it creates it.

File tests (Bash):

• -f = file exists
• -d = directory exists
• -r = file is readable
• -w = file is writable

Real-World: Disk Space Monitor

Bash:

usage=$(df -h / | tail -1 | awk '{print $5}' | sed 's/%//')

if [ $usage -gt 90 ]; then
    echo "CRITICAL: Disk $usage% full!"
    echo "Alert sent on $(date)" >> disk_alerts.log
elif [ $usage -gt 75 ]; then
    echo "WARNING: Disk $usage% full"
elif [ $usage -gt 50 ]; then
    echo "OK: Disk $usage% used"
else
    echo "GOOD: Plenty of space ($usage%)"
fi

PowerShell:

$disk = Get-PSDrive C
$usage = [math]::Round(($disk.Used / ($disk.Used + $disk.Free)) * 100)

if ($usage -gt 90) {
    Write-Host "CRITICAL: Disk $usage% full!" -ForegroundColor Red
    "Alert sent on $(Get-Date)" | Out-File disk_alerts.log -Append
}
elseif ($usage -gt 75) {
    Write-Host "WARNING: Disk $usage% full" -ForegroundColor Yellow
}
elseif ($usage -gt 50) {
    Write-Host "OK: Disk $usage% used" -ForegroundColor Cyan
}
else {
    Write-Host "GOOD: Plenty of space ($usage%)" -ForegroundColor Green
}

Real-world use: Run this daily to monitor disk space and get alerts before you run out!

Bash: Count to 5

for i in 1 2 3 4 5; do
    echo "Number: $i"
done

Output:

Number: 1
Number: 2
Number: 3
Number: 4
Number: 5

Breaking it down:

• for i in = for each item
• 1 2 3 4 5 = the list of items
• do = start of repeated action
• done = end of repeated action

PowerShell: Count to 5

foreach ($i in 1..5) {
    Write-Host "Number: $i"
}

Output: Same as Bash!

Breaking it down:

• foreach = for each item
• $i in 1..5 = variable in range 1 to 5
• { } = curly braces contain repeated code

Cool PowerShell trick: 1..5 automatically creates the range!

List All .txt Files

Bash:

for file in *.txt; do
    echo "Found: $file"
    echo "Size: $(wc -l < "$file") lines"
done

PowerShell:

foreach ($file in Get-ChildItem *.txt) {
    Write-Host "Found: $($file.Name)"
    $lines = (Get-Content $file).Count
    Write-Host "Size: $lines lines"
}

What's happening:

• *.txt = matches all files ending in .txt
• Loop processes each file one at a time
• Could rename, copy, or modify each file!

Rename Multiple Files

Bash:

counter=1
for file in *.jpg; do
    newname="photo_$counter.jpg"
    mv "$file" "$newname"
    echo "Renamed $file to $newname"
    ((counter++))
done

PowerShell:

$counter = 1
foreach ($file in Get-ChildItem *.jpg) {
    $newName = "photo_$counter.jpg"
    Rename-Item $file $newName
    Write-Host "Renamed $($file.Name) to $newName"
    $counter++
}

Result: IMG_1234.jpg → photo_1.jpg, IMG_5678.jpg → photo_2.jpg, etc.

Real-world use: Organize hundreds of downloaded photos instantly!

Backup Script with Logs

Bash:

echo "Starting backup at $(date)"
backup_dir="/backup/$(date +%Y%m%d)"
mkdir -p "$backup_dir"

for folder in Documents Pictures Videos; do
    echo "Backing up $folder..."
    cp -r ~/"$folder" "$backup_dir/"
    if [ $? -eq 0 ]; then
        echo "✓ $folder backed up successfully"
    else
        echo "✗ $folder backup failed!"
    fi
done

echo "Backup completed at $(date)"

PowerShell:

Write-Host "Starting backup at $(Get-Date)"
$backupDir = "C:\Backup\$(Get-Date -Format 'yyyyMMdd')"
New-Item -ItemType Directory -Path $backupDir -Force | Out-Null

foreach ($folder in @("Documents", "Pictures", "Videos")) {
    Write-Host "Backing up $folder..." -ForegroundColor Cyan
    $source = "$env:USERPROFILE\$folder"
    Copy-Item $source $backupDir -Recurse -ErrorAction SilentlyContinue
    if ($?) {
        Write-Host "✓ $folder backed up successfully" -ForegroundColor Green
    }
    else {
        Write-Host "✗ $folder backup failed!" -ForegroundColor Red
    }
}

Write-Host "Backup completed at $(Get-Date)" -ForegroundColor Green

Why this is amazing: One script backs up multiple folders, creates dated backups, and logs success/failure!

Countdown Timer

Bash:

counter=5
while [ $counter -gt 0 ]; do
    echo "$counter seconds remaining..."
    sleep 1
    ((counter--))
done
echo "Time's up!"

PowerShell:

$counter = 5
while ($counter -gt 0) {
    Write-Host "$counter seconds remaining..."
    Start-Sleep -Seconds 1
    $counter--
}
Write-Host "Time's up!" -ForegroundColor Red

What happens: Counts down from 5 to 1, waiting 1 second between each number!