Loops in PowerShell

Analogy categoryAnalogies

The foreach Statement and For Loop

The foreach statement iterates over a collection, binding each element in turn to a loop variable: foreach ($item in $collection) { ... }. It loads the entire collection into memory before iterating, which is fine for arrays and most objects but can be memory-heavy for very large datasets. The classic for loop, for ($i = 0; $i -lt 10; $i++) { ... }, gives explicit control over the counter, making it useful when you need an index, need to skip elements, or need to iterate a fixed number of times rather than over a collection.

🏏

Cricket analogy: Like a scorer running foreach ($over in $innings.Overs) to tally runs over-by-over, versus a for loop counting for ($ball = 1; $ball -le 6; $ball++) to track deliveries within a single over precisely.

ForEach-Object and the Pipeline

ForEach-Object (aliased % or foreach when used in a pipeline) processes one pipeline object at a time, which means it can start working before the entire upstream collection has been produced — useful for streaming large result sets like Get-ChildItem -Recurse. Its -Begin, -Process, and -End parameter sets let you run setup code once, per-item code repeatedly, and cleanup code once, respectively. Because it operates within the pipeline, it composes naturally with cmdlets like Where-Object and Select-Object rather than requiring you to materialize an array first.

🏏

Cricket analogy: Like a live commentary feed processing each ball as it's bowled via ForEach-Object, reacting in real time rather than waiting for the entire over to finish, the way Sky Sports narrates ball-by-ball.

While and Do-While/Do-Until Loops

A while loop, while ($condition) { ... }, checks its condition before each iteration, so the body may never execute if the condition starts false. do { ... } while ($condition) and do { ... } until ($condition) instead check after the body runs, guaranteeing at least one execution — useful for retry logic, menu prompts, or polling a resource that must be checked at least once. do/while continues while the condition is true, while do/until continues until the condition becomes true (i.e., it loops while false), which is easy to invert by mistake.

🏏

Cricket analogy: Like a bowler's over continuing while ($ballsBowled -lt 6), checked before each delivery, versus a do/until retry that always bowls at least once even if a no-ball is called first.

Controlling Loops with break and continue

break immediately exits the innermost loop (or switch), while continue skips the rest of the current iteration and jumps to the next one. Both work inside foreach, for, while, do, and switch. When loops are nested, break and continue can target an outer loop by labeling it with a colon-prefixed name (:outer) placed before the loop keyword and referenced as break outer or continue outer, which avoids the need for extra flag variables to escape multiple levels at once.

🏏

Cricket analogy: Like a bowler being taken out of the attack mid-over with break the moment an injury occurs, versus continue simply skipping to the next ball after a dead-ball call without ending the over.

powershell

$servers = @('web01', 'web02', 'db01', 'cache01')

:serverLoop foreach ($server in $servers) {
    $attempt = 0
    do {
        $attempt++
        $result = Test-Connection -ComputerName $server -Count 1 -Quiet -ErrorAction SilentlyContinue
        if (-not $result -and $attempt -ge 3) {
            Write-Warning "$server unreachable after 3 attempts - skipping."
            continue serverLoop
        }
    } while (-not $result -and $attempt -lt 3)

    if ($server -like 'db*') {
        Write-Host "Critical database host $server is up - stopping scan early."
        break serverLoop
    }

    Write-Host "$server is reachable (attempt $attempt)."
}

ForEach-Object -Parallel (PowerShell 7.1+) runs iterations concurrently using separate runspaces, which can dramatically speed up I/O-bound work like pinging hundreds of servers, but each parallel block runs in its own scope, so variables from the parent scope must be passed explicitly via $using:variableName.

do/while and do/until are easy to confuse: do/while repeats while the condition is TRUE, do/until repeats until the condition becomes TRUE (i.e., while it's false). Swapping one for the other without inverting the condition creates an infinite loop or a loop that never runs its second iteration.

foreach ($item in $collection) iterates a materialized collection; the classic for loop gives explicit counter control.
ForEach-Object processes pipeline objects one at a time and supports -Begin, -Process, and -End blocks.
while checks its condition before running the body; do/while and do/until check after, guaranteeing at least one run.
do/while loops while the condition is true; do/until loops until the condition becomes true (while it's false).
break exits the nearest loop or switch entirely; continue skips to the next iteration.
Labeled loops (:label foreach ...) let break and continue target an outer loop from inside nested loops.
ForEach-Object -Parallel runs iterations concurrently but requires $using: to access parent-scope variables.