Control Flow

The Night I Processed 1,000 Servers

It was 11 PM when I got the call. A critical security patch needed deployment across 1,000 production servers before morning. Manual deployment: 5 minutes per server = 83 hours. I had 7 hours.

I wrote a PowerShell script with loops and conditional logic:

foreach ($server in $servers) {
    if (Test-Connection -ComputerName $server -Count 1 -Quiet) {
        if (Get-HotFix -Id KB5034441 -ComputerName $server -ErrorAction SilentlyContinue) {
            Write-Host "$server already patched"
        } else {
            Install-Patch -ComputerName $server
        }
    } else {
        Write-Warning "$server unreachable"
    }
}

All 1,000 servers: patched in 2 hours. Loops and conditionals aren't just programming concepts - they're force multipliers for operations work.

If Statements

The foundation of conditional logic.

Basic If

$diskSpace = (Get-PSDrive C).Free / 1GB

if ($diskSpace -lt 10) {
    Write-Warning "Disk space low: $diskSpace GB"
}

If-Else

$service = Get-Service -Name "wuauserv"

if ($service.Status -eq 'Running') {
    Write-Host "Service is running"
} else {
    Write-Host "Service is stopped - starting..."
    Start-Service -Name "wuauserv"
}

If-ElseIf-Else

$memory = (Get-CimInstance Win32_OperatingSystem).FreePhysicalMemory / 1MB

if ($memory -lt 100) {
    Write-Warning "CRITICAL: Only $memory MB free"
} elseif ($memory -lt 500) {
    Write-Warning "WARNING: $memory MB free"
} else {
    Write-Host "OK: $memory MB free"
}

Comparison Operators

# Equality
-eq      # Equal
-ne      # Not equal
-gt      # Greater than
-ge      # Greater than or equal
-lt      # Less than
-le      # Less than or equal

# String matching
-like      # Wildcard match
-notlike   # Wildcard not match
-match     # Regex match
-notmatch  # Regex not match

# Containment
-in        # Item in collection
-notin     # Item not in collection
-contains  # Collection contains item
-notcontains  # Collection doesn't contain item

# Type checking
-is        # Is of type
-isnot     # Is not of type

Examples

# String comparison (case-insensitive by default)
if ($env:COMPUTERNAME -like "WEB*") {
    Write-Host "This is a web server"
}

# Case-sensitive comparison
if ($text -ceq "PowerShell") {  # Use -c prefix for case-sensitive
    Write-Host "Exact match"
}

# Regex matching
if ($logLine -match "ERROR|EXCEPTION") {
    Write-Warning "Error found: $logLine"
}

# Type checking
if ($value -is [int]) {
    Write-Host "It's a number"
}

# Containment
$allowedUsers = @("admin", "john", "jane")
if ($currentUser -in $allowedUsers) {
    Write-Host "Access granted"
}

Logical Operators

# AND
if ($cpu -gt 80 -and $memory -lt 100) {
    Write-Warning "High CPU and low memory"
}

# OR
if ($status -eq "Error" -or $status -eq "Failed") {
    Write-Warning "Operation unsuccessful"
}

# NOT
if (-not (Test-Path $filePath)) {
    Write-Warning "File not found"
}

Switch Statements

More elegant than multiple if-elseif chains.

Basic Switch

$dayOfWeek = (Get-Date).DayOfWeek

switch ($dayOfWeek) {
    "Monday"    { Write-Host "Start of work week" }
    "Friday"    { Write-Host "Almost weekend!" }
    "Saturday"  { Write-Host "Weekend!" }
    "Sunday"    { Write-Host "Weekend!" }
    default     { Write-Host "Middle of week" }
}

Switch with Multiple Conditions

$errorCode = 404

switch ($errorCode) {
    200 { Write-Host "OK" }
    201 { Write-Host "Created" }
    {$_ -in 400, 401, 403} { Write-Warning "Client error" }
    {$_ -in 500, 502, 503} { Write-Error "Server error" }
    404 { Write-Warning "Not found" }
    default { Write-Host "Unknown status: $errorCode" }
}

Switch with Wildcard Matching

$serverName = "WEB-PROD-01"

switch -Wildcard ($serverName) {
    "WEB-*"  { $serverType = "Web Server" }
    "DB-*"   { $serverType = "Database Server" }
    "*-PROD-*" { $environment = "Production" }
    "*-DEV-*"  { $environment = "Development" }
}

Switch with Regex

$logEntry = "2024-01-15 ERROR Application crashed"

switch -Regex ($logEntry) {
    "ERROR"   { Write-Warning "Error logged" }
    "WARNING" { Write-Host "Warning logged" }
    "^\d{4}-\d{2}-\d{2}" { Write-Host "Contains date" }
}

Switch on Files

switch -File "config.txt" {
    "Server=*" { 
        $serverLine = $_
        Write-Host "Found server config: $serverLine"
    }
    "Port=*" {
        $portLine = $_
        Write-Host "Found port config: $portLine"
    }
}

ForEach-Object Loop (Pipeline)

Process items coming through the pipeline.

Basic Usage

# Process each process
Get-Process | ForEach-Object {
    Write-Host "Process: $($_.Name) - CPU: $($_.CPU)"
}

# Process files
Get-ChildItem -Filter "*.txt" | ForEach-Object {
    Write-Host "File: $($_.Name) - Size: $($_.Length) bytes"
}

Using -Begin, -Process, -End

Get-ChildItem -File | ForEach-Object -Begin {
    $totalSize = 0
} -Process {
    $totalSize += $_.Length
} -End {
    Write-Host "Total size: $($totalSize / 1MB) MB"
}

ForEach-Object Aliases

# All equivalent
Get-Service | ForEach-Object { $_.Name }
Get-Service | forEach { $_.Name }
Get-Service | % { $_.Name }  # Don't use in scripts!

Foreach Loop (Statement)

Process collections directly (not in pipeline).

Basic Foreach

$servers = @("WEB01", "WEB02", "DB01")

foreach ($server in $servers) {
    Write-Host "Processing $server"
    Test-Connection -ComputerName $server -Count 1
}

Nested Foreach

$environments = @("Dev", "Staging", "Prod")
$serverTypes = @("Web", "DB", "API")

foreach ($env in $environments) {
    foreach ($type in $serverTypes) {
        $serverName = "$type-$env"
        Write-Host "Creating $serverName"
    }
}

Foreach vs ForEach-Object

# ForEach-Object (pipeline) - processes one at a time
Get-Process | ForEach-Object { $_.Name }

# foreach (statement) - loads all into memory first
$processes = Get-Process
foreach ($process in $processes) {
    $process.Name
}

# foreach is faster for collections already in memory
# ForEach-Object better for large datasets or streaming

For Loop

Counter-based iteration.

Basic For Loop

for ($i = 0; $i -lt 10; $i++) {
    Write-Host "Count: $i"
}

Array Iteration

$servers = @("WEB01", "WEB02", "WEB03")

for ($i = 0; $i -lt $servers.Count; $i++) {
    Write-Host "Server $($i + 1): $($servers[$i])"
}

Decrementing Loop

for ($i = 10; $i -gt 0; $i--) {
    Write-Host "Countdown: $i"
}

While and Do-While Loops

Condition-based iteration.

While Loop

$retries = 0
$maxRetries = 5

while ($retries -lt $maxRetries) {
    try {
        # Attempt operation
        Invoke-WebRequest -Uri "https://api.example.com" -ErrorAction Stop
        break  # Success - exit loop
    }
    catch {
        $retries++
        Write-Warning "Attempt $retries failed, retrying..."
        Start-Sleep -Seconds 5
    }
}

Do-While Loop

# Executes at least once
do {
    $response = Read-Host "Continue? (yes/no)"
} while ($response -ne "yes" -and $response -ne "no")

Do-Until Loop

$count = 0

do {
    $count++
    Write-Host "Count: $count"
} until ($count -eq 5)

Break and Continue

Control loop flow.

Break

Exit the loop entirely:

foreach ($server in $servers) {
    if (Test-Connection -ComputerName $server -Count 1 -Quiet) {
        Write-Host "$server is online"
        break  # Stop after first online server
    }
}

Continue

Skip to next iteration:

foreach ($file in Get-ChildItem) {
    if ($file.Extension -ne ".txt") {
        continue  # Skip non-txt files
    }
    Write-Host "Processing: $($file.Name)"
}

Break vs Continue

# Break exits loop
for ($i = 0; $i -lt 10; $i++) {
    if ($i -eq 5) { break }
    Write-Host $i  # Outputs: 0,1,2,3,4
}

# Continue skips to next iteration
for ($i = 0; $i -lt 10; $i++) {
    if ($i -eq 5) { continue }
    Write-Host $i  # Outputs: 0,1,2,3,4,6,7,8,9 (skips 5)
}

Real-World Examples

Batch Processing with Error Handling

$servers = Get-Content "servers.txt"
$results = @()

foreach ($server in $servers) {
    Write-Host "Processing $server..."
    
    $result = [PSCustomObject]@{
        Server = $server
        Status = "Unknown"
        DiskSpace = 0
        Services = @()
    }
    
    if (Test-Connection -ComputerName $server -Count 1 -Quiet) {
        try {
            # Get disk space
            $disk = Get-CimInstance -ComputerName $server -ClassName Win32_LogicalDisk -Filter "DeviceID='C:'"
            $result.DiskSpace = [math]::Round($disk.FreeSpace / 1GB, 2)
            
            # Check critical services
            $criticalServices = @('wuauserv', 'W32Time')
            $stoppedServices = Invoke-Command -ComputerName $server -ScriptBlock {
                param($services)
                Get-Service -Name $services | Where-Object {$_.Status -ne 'Running'} | Select-Object -ExpandProperty Name
            } -ArgumentList (,$criticalServices)
            
            $result.Services = $stoppedServices
            $result.Status = "Online"
        }
        catch {
            $result.Status = "Error: $_"
        }
    }
    else {
        $result.Status = "Offline"
    }
    
    $results += $result
}

$results | Export-Csv "server-health.csv" -NoTypeInformation

Retry Logic

function Invoke-WithRetry {
    param(
        [scriptblock]$ScriptBlock,
        [int]$MaxRetries = 3,
        [int]$DelaySeconds = 5
    )
    
    $attempt = 0
    
    while ($attempt -lt $MaxRetries) {
        try {
            & $ScriptBlock
            return  # Success
        }
        catch {
            $attempt++
            if ($attempt -lt $MaxRetries) {
                Write-Warning "Attempt $attempt failed: $_. Retrying in $DelaySeconds seconds..."
                Start-Sleep -Seconds $DelaySeconds
            }
            else {
                Write-Error "All $MaxRetries attempts failed"
                throw
            }
        }
    }
}

# Usage
Invoke-WithRetry -ScriptBlock {
    Invoke-RestMethod -Uri "https://api.example.com/data"
}

Parallel Processing (Simplified)

$servers = 1..100 | ForEach-Object { "SERVER$($_.ToString('000'))" }
$batchSize = 10

for ($i = 0; $i -lt $servers.Count; $i += $batchSize) {
    $batch = $servers[$i..([math]::Min($i + $batchSize - 1, $servers.Count - 1))]
    
    Write-Host "Processing batch $(($i / $batchSize) + 1)..."
    
    foreach ($server in $batch) {
        # Process server
        Test-Connection -ComputerName $server -Count 1 -AsJob | Out-Null
    }
    
    # Wait for batch to complete
    Get-Job | Wait-Job | Remove-Job
}

Common Pitfalls

1. Modifying Collection While Iterating

Problem: Can't modify collection you're iterating Solution: Create new collection or use for loop with index

# Bad
foreach ($item in $collection) {
    $collection.Remove($item)  # Error!
}

# Good
$itemsToRemove = $collection | Where-Object {$_ -eq "remove-me"}
foreach ($item in $itemsToRemove) {
    $collection.Remove($item)
}

2. Forgetting Break in Switch

Problem: Switch continues to next case Solution: Use break or understand fall-through behavior

switch ($value) {
    1 { Write-Host "One"; break }
    2 { Write-Host "Two"; break }
    default { Write-Host "Other" }
}

3. Infinite Loops

Problem: While loop condition never becomes false Solution: Ensure condition will eventually fail or use break

# Bad - infinite
while ($true) {
    # No break!
}

# Good - with break condition
while ($true) {
    if ($condition) { break }
}

Key Takeaways

• If/ElseIf/Else for conditional logic

• Switch for multiple conditions (more elegant than if chains)

• ForEach-Object for pipeline processing

• foreach for collection iteration

• for for counter-based loops

• while/do-while for condition-based loops

• break exits loop, continue skips iteration

• Comparison operators are fundamental to conditions

What You've Learned

✅ If statements and conditional logic ✅ Switch statements with wildcards and regex ✅ ForEach-Object vs foreach loops ✅ for, while, and do-while loops ✅ break and continue for loop control ✅ Real-world batch processing patterns ✅ Retry logic implementation

Next Steps

Loops and conditions are powerful, but scripts fail. In Error Handling, you'll learn:

• Try/Catch/Finally blocks

• Error types and $Error variable

• ErrorAction preferences

• Building resilient scripts

• Logging errors properly

Proper error handling separates toy scripts from production code.

---

Ready to handle errors like a pro? Continue to Error Handling →