Kontrollstrukturen: if, switch, for, foreach, while

Mit Variablen und Pipeline aus L3 kannst du Daten verarbeiten. Aber sobald deine Skripte mehr machen sollen als linear Befehle abzuarbeiten, brauchst du Verzweigungen (if/switch) und Schleifen (for/foreach/while). Hier zeigt sich PowerShell von einer eher klassischen Programmiersprachen-Seite – die Syntax erinnert an C# oder Java.

Eine Eigenheit vorab: PowerShell hat zwei foreach-Varianten, die gleich heißen aber unterschiedlich arbeiten. Das verwirrt am Anfang – wir gehen es geordnet durch. Wer aus Bash kommt, findet vieles vertraut, aber mit C-ähnlicher Syntax statt Bash-Schlüsselwörtern.

1) Die if-Anweisung

Wie in fast jeder Sprache: if (BEDINGUNG) { ... }. Geschweifte Klammern um den Block, runde um die Bedingung – also wie in Java oder C, nicht wie in Bash mit then ... fi:

if/elseif/else live verfolgen

$status =

Beachte: geschweifte Klammern sind Pflicht, auch bei einzeiligem Block. if ($x) Aktion wie in C funktioniert NICHT in PowerShell. Vergleichs-Operatoren sind -eq, -ne, -lt, -le, -gt, -ge – siehe L3. Auch nicht == wie in den meisten Programmiersprachen – das ist ein extrem häufiger Anfängerfehler.

2) Truthy und Falsy: was ist „wahr"?

PowerShell hat eine eigene Logik was als „wahr" gilt. Wichtig zu wissen weil if ($x) { ... } oft auch ohne expliziten Vergleich genutzt wird:

Wert	Wahrheitswert
`$true`	$true ✓
`$false` / `$null` / `0` / `""` / `@()`	$false
`1` oder jede andere Zahl ≠ 0	$true ✓
`"text"` (nicht leerer String)	$true ✓
`@($null)` (Array mit 1 Element, auch wenn null)	$true ✓
`"$false"` oder `"False"` (String mit Wort)	$true ✓ – Falle!

Der letzte Punkt ist eine berüchtigte Stolperfalle: "False" ist ein NICHT-leerer String → wahr. Wenn Werte aus einer CSV-Datei kommen, sind sie oft Strings – und dann gilt if ($csv.IsActive) { ... } auch wenn IsActive den Text „False" enthält. Sicherer: if ($csv.IsActive -eq "True") { ... } oder Konvertierung mit [bool]::Parse($csv.IsActive).

3) Switch – die mächtige Verzweigung

Bei vielen Möglichkeiten wird if-elseif-elseif unleserlich. switch ist eleganter – und in PowerShell sogar mächtiger als in vielen anderen Sprachen, weil es Patterns und Regex unterstützt:

switch-Anweisung interaktiv

$rolle =

Wichtig: anders als in vielen Sprachen laufen ALLE matching cases durch – kein implizites Break. Mit break kannst du nach einem Match abbrechen. default matcht wenn keiner der anderen passt (wie else). Switch unterstützt auch -Wildcard für Glob-Patterns, -Regex für reguläre Ausdrücke, -CaseSensitive für strikte Vergleiche – damit ist es deutlich mächtiger als case in Bash.

Switch mit Pattern-Matching wird oft für Eingabe-Validierung verwendet:

# Mit -Regex: matchen mit regulären Ausdrücken switch -Regex ($eingabe) { "^[0-9]+$" { Write-Host "Ist eine Zahl" } "^[a-zA-Z]+$" { Write-Host "Nur Buchstaben" } "^.+@.+\.[a-z]+$" { Write-Host "Sieht aus wie E-Mail" } default { Write-Host "Unbekanntes Format" } } # Mit -Wildcard: Glob-Pattern switch -Wildcard ($datei) { "*.txt" { Write-Host "Textdatei" } "*.jpg" { Write-Host "Bild" } "*.log" { Write-Host "Logdatei" } default { Write-Host "Sonstiges" } } # Switch über ein ARRAY: jedes Element wird einzeln getestet switch (@("admin", "user", "guest", "admin")) { "admin" { Write-Host "Admin gefunden" } "user" { Write-Host "User gefunden" } } # Output: "Admin gefunden", "User gefunden", "Admin gefunden" (dreimal!)

4) Schleifen: Übersicht

PowerShell hat vier Schleifen-Konstrukte. Plus den Pipeline-Verwandten ForEach-Object aus L3. Das wirkt erstmal viel – wir bauen es geordnet auf:

Form	Zweck	Beispiel
`for`	Zähl-Schleife, C-Style	`for ($i=0; $i -lt 10; $i++)`
`foreach`	Über Collection, als Statement	`foreach ($x in $array) { ... }`
`ForEach-Object`	Pipeline-Cmdlet, jedes Element	`$array \| ForEach-Object { ... }`
`while`	Solange Bedingung wahr	`while ($x -gt 0) { ... }`
`do...while`	Mind. einmal, dann prüfen	`do { ... } while ($x -gt 0)`
`do...until`	Mind. einmal, bis Bedingung wahr	`do { ... } until ($fertig)`

5) Die verschiedenen Loop-Varianten in Aktion

Loop-Varianten ausprobieren

for (C-Style)

foreach

ForEach-Object

while

do-while

6) foreach-Statement vs. ForEach-Object

Hier kommt die berühmte Verwirrung. Es gibt foreach als Sprach-Konstrukt und ForEach-Object als Cmdlet. Beide iterieren über Collections – aber mit unterschiedlichen Eigenschaften:

foreach vs. ForEach-Object

foreach (Statement)

ForEach-Object (Cmdlet)

Faustregel: kleine Collections und Skript-Kontext → foreach-Statement (lesbar, schnell). Pipeline und große/streamende Daten → ForEach-Object (effizient bei Memory, gehört in die Pipeline). Beides hat seine Berechtigung. Übrigens: foreach ist auch ein Alias für ForEach-Object (in interaktivem Modus) – das macht alles noch verwirrender. In Skripten ausgeschriebene Form ForEach-Object nutzen.

7) Schleifen-Kontrolle: break und continue

In jeder Schleife kannst du den Flow steuern. Das funktioniert wie in Java oder Python:

# break: Schleife komplett verlassen foreach ($service in Get-Service) { if ($service.Name -eq "NotFound") { Write-Host "Stop-Service gefunden, breche ab" break } Write-Host $service.Name } # continue: aktuellen Durchlauf überspringen foreach ($datei in Get-ChildItem) { if ($datei.PSIsContainer) { continue # Verzeichnisse überspringen } Write-Host "Datei: $($datei.Name)" }

Wichtiger Unterschied zu ForEach-Object: in ForEach-Object { ... } verhalten sich break und continue NICHT wie in Schleifen – sie sind als „normaler Code im ScriptBlock" interpretiert. continue in ForEach-Object überspringt nicht den nächsten Pipeline-Schritt, sondern beendet den Block. Für „nur dieses Element überspringen" in ForEach-Object: return nutzen.

# RICHTIG in foreach-Statement foreach ($x in $liste) { if ($x -eq 0) { continue } # überspringen, geht zur nächsten Write-Host $x } # RICHTIG in ForEach-Object $liste | ForEach-Object { if ($_ -eq 0) { return } # beendet NUR diesen Block, nächstes Element kommt Write-Host $_ }

8) Try-Catch-Finally für Fehlerbehandlung

Im Gegensatz zu Bash mit Exit-Codes arbeitet PowerShell mit Exceptions – wie Python oder Java. Tritt ein Fehler auf, wird er „geworfen" und kann mit try/catch gefangen werden:

try { $inhalt = Get-Content -Path "C:\config.txt" -ErrorAction Stop Write-Host "Datei geladen: $inhalt.Length Bytes" } catch [System.IO.FileNotFoundException] { Write-Host "Datei fehlt: $_" -ForegroundColor Red } catch [System.UnauthorizedAccessException] { Write-Host "Keine Berechtigung" -ForegroundColor Red } catch { # Catch-all für alle anderen Fehler Write-Host "Unbekannter Fehler: $_" } finally { Write-Host "Aufräumen läuft immer - auch bei Fehler" }

Wichtige Eigenheit: viele Cmdlets werfen standardmäßig keine Exceptions! Sie geben nur Warnungen aus und laufen weiter (sog. „Non-Terminating Errors"). Erst mit -ErrorAction Stop wird daraus eine fangbare Exception. Das ist die wichtigste Falle bei try-catch – wer es vergisst, dessen catch-Block läuft nie. Mehr zu Fehlerbehandlung in L5 Funktionen.

9) Praktisches Beispiel: Service-Health-Check

Lass uns das Gelernte kombinieren – ein realistisches FISI-Skript:

# Service-Status prüfen und kritische restarten $kritisch = @("Spooler", "BITS", "W32Time") $report = @() # leeres Array für Report foreach ($name in $kritisch) { try { $svc = Get-Service -Name $name -ErrorAction Stop switch ($svc.Status) { "Running" { $report += "$name: OK" } "Stopped" { Write-Host "Starte $name neu..." -ForegroundColor Yellow Start-Service $name $report += "$name: NEUSTART" } default { $report += "$name: STATUS=$($svc.Status)" } } } catch { $report += "$name: FEHLER - $_" } } $report | ForEach-Object { Write-Host $_ }

Dieses Skript zeigt alle Bausteine zusammen: foreach-Statement für die Liste, try-catch für die Fehler, switch für die Status-Verzweigung, Array-Aufbau mit +=, am Ende Pipeline mit ForEach-Object. So sehen produktive PowerShell-Skripte aus.

10) Häufige Stolperfallen

Die typischen Anfänger-Fallen bei Kontrollstrukturen:

== statt -eq: if ($a == 5) ist syntaktisch erlaubt aber tut etwas Unerwartetes – PowerShell interpretiert es als Aufruf eines Cmdlets oder Strings. Richtig: if ($a -eq 5).
Vergessenes -ErrorAction Stop: try-catch fängt nur „terminating errors". Bei Get-Service nichtExistent wird's nur eine Warnung, kein Stop. Mit -ErrorAction Stop wird daraus eine Exception.
String als Bool: if ("false") ist WAHR. Aus CSV kommen alle Werte als Strings. Sicherheitshalber: -eq "true" explizit vergleichen.
break/continue in ForEach-Object: funktioniert nicht wie erwartet. Nutze return für continue-Effekt, oder benutze die foreach-Statement-Variante.
Endlosschleife mit while: vergessenes $i++ oder vergessenes break – Skript hängt. Notfall: Strg+C oder Konsole schließen.

Zusammenfassung

if/elseif/else: if ($x -eq 5) { ... } elseif (...) { ... } else { ... } – geschweifte Klammern Pflicht, Operatoren mit Bindestrich (-eq, -lt, ...). Truthy/Falsy: $null/0/""/leeres-Array sind falsch, alles andere wahr (Vorsicht bei String "False"!). switch: mächtig mit -Regex, -Wildcard, -CaseSensitive und Pattern-Block. Schleifen: for (C-Style mit Zähler), foreach (Statement über Collection, sammelt alles vorher), ForEach-Object (Pipeline-Cmdlet, streamt einzeln), while/do-while/do-until. break/continue für Schleifen-Kontrolle (in ForEach-Object: return). try/catch/finally mit -ErrorAction Stop für Fehlerbehandlung. Wichtig: foreach-Statement ≠ ForEach-Object-Cmdlet – Statement sammelt zuerst, Cmdlet streamt. Häufige Fehler: == statt -eq, vergessenes -ErrorAction Stop, String als Bool.