Zum Inhalt springen

Powershell - Kontrollstrukturen

Aus Gerhards Wiki
Version vom 6. November 2025, 20:46 Uhr von Gerhard (Diskussion | Beiträge) (Die Seite wurde neu angelegt: „== Kursübersicht == '''Voraussetzungen:''' Kurs 1, 2 und 3 abgeschlossen '''Lernziele:''' * Du triffst Entscheidungen mit If-Else und Switch * Du verwendest verschiedene Schleifentypen effektiv * Du verstehst Vergleichs- und logische Operatoren * Du steuerst den Programmfluss mit Break, Continue und Return * Du schreibst robuste, logische Skripte ---- == Modul 4.1: Vergleichsoperatoren == === Grundlegende Vergleichsoperatoren === PowerShell verwend…“)
(Unterschied) ← Nächstältere Version | Aktuelle Version (Unterschied) | Nächstjüngere Version → (Unterschied)

Voraussetzungen: Kurs 1, 2 und 3 abgeschlossen

Lernziele:

  • Du triffst Entscheidungen mit If-Else und Switch
  • Du verwendest verschiedene Schleifentypen effektiv
  • Du verstehst Vergleichs- und logische Operatoren
  • Du steuerst den Programmfluss mit Break, Continue und Return
  • Du schreibst robuste, logische Skripte

Modul 4.1: Vergleichsoperatoren

[Bearbeiten | Quelltext bearbeiten]

Grundlegende Vergleichsoperatoren

[Bearbeiten | Quelltext bearbeiten]

PowerShell verwendet spezielle Operatoren für Vergleiche (nicht wie andere Sprachen mit ==, !=):

Operator Bedeutung Beispiel Ergebnis
-eq Equal (gleich) 5 -eq 5 $true
-ne Not Equal (ungleich) 5 -ne 3 $true
-gt Greater Than (größer) 10 -gt 5 $true
-ge Greater or Equal (größer oder gleich) 5 -ge 5 $true
-lt Less Than (kleiner) 3 -lt 5 $true
-le Less or Equal (kleiner oder gleich) 5 -le 5 $true
# Einfache Vergleiche
5 -eq 5          # True
10 -gt 5         # True
3 -lt 10         # True
"Hallo" -eq "Hallo"  # True

# Mit Variablen
$alter = 25
$alter -ge 18    # True (volljährig)
$alter -lt 30    # True
ℹ️
Hinweis
PowerShell-Vergleiche sind standardmäßig case-insensitive bei Strings!

String-Vergleiche

[Bearbeiten | Quelltext bearbeiten]
# Case-insensitive (Standard)
"Hallo" -eq "hallo"       # True
"PowerShell" -eq "powershell"  # True

# Case-sensitive (mit 'c' Präfix)
"Hallo" -ceq "hallo"      # False
"PowerShell" -ceq "PowerShell"  # True

# Alle Operatoren haben case-sensitive Varianten
"Text" -cne "text"        # True (case-sensitive ungleich)
"Abc" -cgt "abc"          # False

Pattern-Matching-Operatoren

[Bearbeiten | Quelltext bearbeiten]
Operator Beschreibung Beispiel
-like Wildcard-Vergleich (* und ?) "test.txt" -like "*.txt"
-notlike Nicht wie Wildcard "file.doc" -notlike "*.txt"
-match Regex-Vergleich "abc123" -match "\d+"
-notmatch Nicht matchen "hello" -notmatch "\d"
# -like mit Wildcards
$datei = "dokument.txt"
$datei -like "*.txt"              # True
$datei -like "dok*"               # True
$datei -like "???ument.txt"       # True (* = beliebig viele, ? = genau eins)

# -match mit Regex
$email = "user@example.com"
$email -match "@"                 # True
$email -match "^\w+@\w+\.\w+$"   # True (Email-Pattern)

$text = "Telefon: 0123-456789"
if ($text -match "\d{4}-\d{6}") {
    Write-Host "Telefonnummer gefunden: $($Matches[0])"
}

Logische Operatoren

[Bearbeiten | Quelltext bearbeiten]
Operator Bedeutung Beispiel
-and Logisches UND ($a -gt 5) -and ($b -lt 10)
-or Logisches ODER ($a -eq 1) -or ($a -eq 2)
-not oder ! Logisches NICHT -not $aktiv oder !$aktiv
-xor Exklusives ODER $a -xor $b
$alter = 25
$fuehrerschein = $true

# AND - beide Bedingungen müssen wahr sein
if (($alter -ge 18) -and $fuehrerschein) {
    Write-Host "Darf Auto fahren"
}

# OR - mindestens eine Bedingung muss wahr sein
$tag = "Samstag"
if (($tag -eq "Samstag") -or ($tag -eq "Sonntag")) {
    Write-Host "Wochenende!"
}

# NOT - Negation
$verbindung = $false
if (-not $verbindung) {
    Write-Host "Keine Verbindung"
}

# Komplexe Bedingung
if (($alter -ge 18) -and ($alter -lt 65) -and $fuehrerschein) {
    Write-Host "Im arbeitsfähigen Alter und fahrtüchtig"
}

Containment-Operatoren

[Bearbeiten | Quelltext bearbeiten]
Operator Beschreibung Beispiel
-contains Array enthält Wert @(1,2,3) -contains 2
-notcontains Array enthält nicht @(1,2,3) -notcontains 5
-in Wert ist in Array 2 -in @(1,2,3)
-notin Wert nicht in Array 5 -notin @(1,2,3)
$erlaubteRollen = @("Admin", "Editor", "Viewer")
$benutzerRolle = "Editor"

# Prüfen ob Rolle erlaubt ist
if ($benutzerRolle -in $erlaubteRollen) {
    Write-Host "Zugriff gewährt"
}

# Prozessnamen prüfen
$laufendeProzesse = (Get-Process).Name
if ("chrome" -in $laufendeProzesse) {
    Write-Host "Chrome läuft"
}

Modul 4.2: If-Else-Anweisungen

[Bearbeiten | Quelltext bearbeiten]
# Einfaches If
$alter = 20

if ($alter -ge 18) {
    Write-Host "Du bist volljährig"
}

# If mit Bedingung und Aktion
$temperatur = 30

if ($temperatur -gt 25) {
    Write-Host "Es ist heiß draußen!"
}
$alter = 16

if ($alter -ge 18) {
    Write-Host "Du darfst wählen"
} else {
    Write-Host "Du bist noch zu jung zum Wählen"
}

# Mit mehreren Aktionen
$passwort = "geheim123"

if ($passwort.Length -ge 8) {
    Write-Host "Passwort ist lang genug"
    $sicher = $true
} else {
    Write-Host "Passwort ist zu kurz"
    $sicher = $false
}
$note = 85

if ($note -ge 90) {
    Write-Host "Sehr gut!"
    $bewertung = "A"
} elseif ($note -ge 80) {
    Write-Host "Gut"
    $bewertung = "B"
} elseif ($note -ge 70) {
    Write-Host "Befriedigend"
    $bewertung = "C"
} elseif ($note -ge 60) {
    Write-Host "Ausreichend"
    $bewertung = "D"
} else {
    Write-Host "Nicht bestanden"
    $bewertung = "F"
}

Verschachtelte If-Anweisungen

[Bearbeiten | Quelltext bearbeiten]
$alter = 25
$fuehrerschein = $true
$auto = $true

if ($alter -ge 18) {
    if ($fuehrerschein) {
        if ($auto) {
            Write-Host "Du kannst jetzt losfahren!"
        } else {
            Write-Host "Du brauchst ein Auto"
        }
    } else {
        Write-Host "Du brauchst einen Führerschein"
    }
} else {
    Write-Host "Du bist zu jung zum Fahren"
}

# Besser: Mit AND kombinieren
if (($alter -ge 18) -and $fuehrerschein -and $auto) {
    Write-Host "Du kannst jetzt losfahren!"
}

Inline If (Ternärer Operator - ab PowerShell 7)

[Bearbeiten | Quelltext bearbeiten]
# PowerShell 7+
$alter = 20
$status = ($alter -ge 18) ? "Erwachsen" : "Minderjährig"

# Vor PowerShell 7: If-Else in einer Zeile
$status = if ($alter -ge 18) { "Erwachsen" } else { "Minderjährig" }
💡
Tipp
Halte If-Anweisungen so einfach wie möglich. Bei vielen ElseIf-Blöcken ist Switch oft übersichtlicher!

Modul 4.3: Switch-Anweisungen

[Bearbeiten | Quelltext bearbeiten]

Grundlegende Switch-Syntax

[Bearbeiten | Quelltext bearbeiten]
$tag = "Montag"

switch ($tag) {
    "Montag"    { Write-Host "Wochenstart! ☕" }
    "Dienstag"  { Write-Host "Zweiter Tag" }
    "Mittwoch"  { Write-Host "Mitte der Woche" }
    "Donnerstag" { Write-Host "Fast geschafft" }
    "Freitag"   { Write-Host "TGIF! 🎉" }
    "Samstag"   { Write-Host "Wochenende!" }
    "Sonntag"   { Write-Host "Entspannung" }
    default     { Write-Host "Unbekannter Tag" }
}

Switch mit Zahlen

[Bearbeiten | Quelltext bearbeiten]
$monat = 3

switch ($monat) {
    1  { $monatsName = "Januar" }
    2  { $monatsName = "Februar" }
    3  { $monatsName = "März" }
    4  { $monatsName = "April" }
    5  { $monatsName = "Mai" }
    6  { $monatsName = "Juni" }
    7  { $monatsName = "Juli" }
    8  { $monatsName = "August" }
    9  { $monatsName = "September" }
    10 { $monatsName = "Oktober" }
    11 { $monatsName = "November" }
    12 { $monatsName = "Dezember" }
    default { $monatsName = "Ungültig" }
}

Write-Host "Monat: $monatsName"

Switch mit mehreren Werten

[Bearbeiten | Quelltext bearbeiten]
$tag = "Samstag"

switch ($tag) {
    {$_ -in @("Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag")} {
        Write-Host "Arbeitstag"
    }
    {$_ -in @("Samstag", "Sonntag")} {
        Write-Host "Wochenende"
    }
}

# Alternative: Mehrere Labels
switch ($tag) {
    "Montag"    { Write-Host "Arbeitstag"; break }
    "Dienstag"  { Write-Host "Arbeitstag"; break }
    "Mittwoch"  { Write-Host "Arbeitstag"; break }
    "Donnerstag" { Write-Host "Arbeitstag"; break }
    "Freitag"   { Write-Host "Arbeitstag"; break }
    "Samstag"   { Write-Host "Wochenende"; break }
    "Sonntag"   { Write-Host "Wochenende"; break }
}

Switch mit Wildcards

[Bearbeiten | Quelltext bearbeiten]
$datei = "dokument.txt"

switch -Wildcard ($datei) {
    "*.txt"  { Write-Host "Text-Datei" }
    "*.doc*" { Write-Host "Word-Dokument" }
    "*.pdf"  { Write-Host "PDF-Datei" }
    "*.jpg"  { Write-Host "Bild-Datei" }
    default  { Write-Host "Unbekannter Dateityp" }
}

Switch mit Regex

[Bearbeiten | Quelltext bearbeiten]
$eingabe = "BenutzerID: 12345"

switch -Regex ($eingabe) {
    "^\d+$"           { Write-Host "Nur Zahlen" }
    "^[A-Za-z]+$"     { Write-Host "Nur Buchstaben" }
    "\d+"             { Write-Host "Enthält Zahlen" }
    "@"               { Write-Host "Enthält @-Zeichen" }
    default           { Write-Host "Gemischter Inhalt" }
}

Switch mit Arrays

[Bearbeiten | Quelltext bearbeiten]
# Switch kann über Arrays iterieren
$zahlen = @(1, 2, 3, 4, 5)

switch ($zahlen) {
    1 { Write-Host "Eins" }
    2 { Write-Host "Zwei" }
    3 { Write-Host "Drei" }
    default { Write-Host "Andere Zahl: $_" }
}

# Ausgabe:
# Eins
# Zwei
# Drei
# Andere Zahl: 4
# Andere Zahl: 5

Break in Switch

[Bearbeiten | Quelltext bearbeiten]
# Ohne break: Alle passenden Fälle werden ausgeführt
$zahl = 2

switch ($zahl) {
    {$_ -gt 0} { Write-Host "Positiv" }
    {$_ -lt 10} { Write-Host "Kleiner als 10" }
    {$_ % 2 -eq 0} { Write-Host "Gerade" }
}
# Ausgabe: Positiv, Kleiner als 10, Gerade

# Mit break: Stoppt nach erstem Match
switch ($zahl) {
    {$_ -gt 0} { Write-Host "Positiv"; break }
    {$_ -lt 10} { Write-Host "Kleiner als 10" }
    {$_ % 2 -eq 0} { Write-Host "Gerade" }
}
# Ausgabe: nur Positiv
ℹ️
Hinweis
Switch ohne break führt alle passenden Fälle aus. Mit break stoppt es nach dem ersten Match.

Modul 4.4: For-Schleifen

[Bearbeiten | Quelltext bearbeiten]

Klassische For-Schleife

[Bearbeiten | Quelltext bearbeiten]
# Struktur: for (Initialisierung; Bedingung; Inkrement)
for ($i = 0; $i -lt 10; $i++) {
    Write-Host "Zähler: $i"
}

# Von 1 bis 10
for ($i = 1; $i -le 10; $i++) {
    Write-Host $i
}

# Rückwärts zählen
for ($i = 10; $i -ge 0; $i--) {
    Write-Host $i
}

# In Zweierschritten
for ($i = 0; $i -le 20; $i += 2) {
    Write-Host "Gerade Zahl: $i"
}

For-Schleife mit Arrays

[Bearbeiten | Quelltext bearbeiten]
$namen = @("Anna", "Bob", "Clara", "David")

# Mit Index
for ($i = 0; $i -lt $namen.Count; $i++) {
    Write-Host "$($i+1). $($namen[$i])"
}

# Ausgabe:
# 1. Anna
# 2. Bob
# 3. Clara
# 4. David

Verschachtelte For-Schleifen

[Bearbeiten | Quelltext bearbeiten]
# Multiplikationstabelle
for ($i = 1; $i -le 10; $i++) {
    for ($j = 1; $j -le 10; $j++) {
        $ergebnis = $i * $j
        Write-Host "$i x $j = $ergebnis"
    }
    Write-Host "---"
}

# Muster zeichnen
for ($zeile = 1; $zeile -le 5; $zeile++) {
    $sterne = ""
    for ($spalte = 1; $spalte -le $zeile; $spalte++) {
        $sterne += "*"
    }
    Write-Host $sterne
}
# Ausgabe:
# *
# **
# ***
# ****
# *****

Unendliche Schleife (mit Vorsicht!)

[Bearbeiten | Quelltext bearbeiten]
# VORSICHT: Unendliche Schleife!
# Nur mit Break-Bedingung verwenden
for (;;) {
    $eingabe = Read-Host "Eingabe (q zum Beenden)"
    if ($eingabe -eq "q") {
        break
    }
    Write-Host "Du hast eingegeben: $eingabe"
}

Modul 4.5: ForEach-Schleifen

[Bearbeiten | Quelltext bearbeiten]

ForEach-Anweisung

[Bearbeiten | Quelltext bearbeiten]
# Einfaches ForEach
$zahlen = @(1, 2, 3, 4, 5)

foreach ($zahl in $zahlen) {
    Write-Host "Zahl: $zahl"
}

# Mit Strings
$namen = @("Anna", "Bob", "Clara")

foreach ($name in $namen) {
    Write-Host "Hallo, $name!"
}

# Mit Objekten
$prozesse = Get-Process | Select-Object -First 5

foreach ($prozess in $prozesse) {
    Write-Host "$($prozess.Name) - ID: $($prozess.Id)"
}

ForEach mit Berechnungen

[Bearbeiten | Quelltext bearbeiten]
$zahlen = 1..10

$summe = 0
foreach ($zahl in $zahlen) {
    $summe += $zahl
}
Write-Host "Summe: $summe"  # 55

# Quadrate berechnen
$quadrate = @()
foreach ($zahl in 1..5) {
    $quadrate += $zahl * $zahl
}
Write-Host "Quadrate: $($quadrate -join ', ')"  # 1, 4, 9, 16, 25

ForEach mit Hashtables

[Bearbeiten | Quelltext bearbeiten]
$benutzer = @{
    anna = "Admin"
    bob = "User"
    clara = "Editor"
}

foreach ($key in $benutzer.Keys) {
    Write-Host "$key hat die Rolle: $($benutzer[$key])"
}

# Mit GetEnumerator()
foreach ($eintrag in $benutzer.GetEnumerator()) {
    Write-Host "$($eintrag.Key) = $($eintrag.Value)"
}

ForEach vs. ForEach-Object

[Bearbeiten | Quelltext bearbeiten]
# ForEach-Anweisung (schneller, mehr Kontrolle)
$namen = @("Anna", "Bob", "Clara")
foreach ($name in $namen) {
    Write-Host $name
}

# ForEach-Object in Pipeline (Pipeline-freundlich)
$namen | ForEach-Object {
    Write-Host $_
}

# Kurzform mit %
$namen | % { Write-Host $_ }

# Mit mehrzeiligem Block
Get-Process | ForEach-Object {
    $name = $_.Name
    $mem = [math]::Round($_.WorkingSet / 1MB, 2)
    Write-Host "$name : $mem MB"
}
💡
Tipp
Verwende foreach-Anweisung für Arrays/Collections, ForEach-Object für Pipeline-Verarbeitung.

Modul 4.6: While und Do-While

[Bearbeiten | Quelltext bearbeiten]
# While: Prüft Bedingung VOR der Ausführung
$zaehler = 0

while ($zaehler -lt 5) {
    Write-Host "Zähler: $zaehler"
    $zaehler++
}

# Mit Benutzereingabe
$antwort = ""
while ($antwort -ne "ja") {
    $antwort = Read-Host "Möchtest du fortfahren? (ja/nein)"
    if ($antwort -eq "nein") {
        Write-Host "Abgebrochen"
        break
    }
}

Do-While-Schleife

[Bearbeiten | Quelltext bearbeiten]
# Do-While: Führt mindestens einmal aus, prüft NACH der Ausführung
$zaehler = 0

do {
    Write-Host "Zähler: $zaehler"
    $zaehler++
} while ($zaehler -lt 5)

# Unterschied zu While
$zahl = 10

# While: Wird NICHT ausgeführt
while ($zahl -lt 5) {
    Write-Host "While: $zahl"
}

# Do-While: Wird EINMAL ausgeführt
do {
    Write-Host "Do-While: $zahl"
} while ($zahl -lt 5)

Do-Until-Schleife

[Bearbeiten | Quelltext bearbeiten]
# Do-Until: Läuft bis Bedingung TRUE ist (umgekehrt zu While)
$versuch = 0

do {
    $versuch++
    $zahl = Get-Random -Minimum 1 -Maximum 10
    Write-Host "Versuch $versuch : $zahl"
} until ($zahl -eq 7)

Write-Host "Zahl 7 gefunden nach $versuch Versuchen!"

Praktisches Beispiel: Menü

[Bearbeiten | Quelltext bearbeiten]
$beenden = $false

while (-not $beenden) {
    Clear-Host
    Write-Host "=== Hauptmenü ==="
    Write-Host "1. Option 1"
    Write-Host "2. Option 2"
    Write-Host "3. Option 3"
    Write-Host "4. Beenden"
    
    $auswahl = Read-Host "Deine Wahl"
    
    switch ($auswahl) {
        "1" { Write-Host "Option 1 gewählt"; Start-Sleep 2 }
        "2" { Write-Host "Option 2 gewählt"; Start-Sleep 2 }
        "3" { Write-Host "Option 3 gewählt"; Start-Sleep 2 }
        "4" { $beenden = $true }
        default { Write-Host "Ungültige Wahl"; Start-Sleep 2 }
    }
}

Write-Host "Programm beendet"

Modul 4.7: Break, Continue und Return

[Bearbeiten | Quelltext bearbeiten]

break beendet die aktuelle Schleife sofort:

# Schleife abbrechen
for ($i = 1; $i -le 10; $i++) {
    if ($i -eq 5) {
        Write-Host "Bei 5 abgebrochen"
        break
    }
    Write-Host $i
}
# Ausgabe: 1, 2, 3, 4, Bei 5 abgebrochen

# Ersten passenden Wert finden
$zahlen = @(2, 4, 7, 8, 10)
$ungerade = $null

foreach ($zahl in $zahlen) {
    if ($zahl % 2 -ne 0) {
        $ungerade = $zahl
        break  # Stoppen nach erstem Fund
    }
}
Write-Host "Erste ungerade Zahl: $ungerade"

continue überspringt den Rest der aktuellen Iteration und macht mit der nächsten weiter:

# Gerade Zahlen überspringen
for ($i = 1; $i -le 10; $i++) {
    if ($i % 2 -eq 0) {
        continue  # Überspringt gerade Zahlen
    }
    Write-Host $i
}
# Ausgabe: 1, 3, 5, 7, 9 (nur ungerade)

# Fehlerhafte Einträge überspringen
$dateien = @("file1.txt", "file2.log", "file3.txt", "file4.doc")

foreach ($datei in $dateien) {
    if ($datei -notlike "*.txt") {
        continue  # Nicht-TXT-Dateien überspringen
    }
    Write-Host "Verarbeite: $datei"
}

return beendet eine Funktion/ein Skript und gibt optional einen Wert zurück:

function Pruefe-Alter {
    param([int]$alter)
    
    if ($alter -lt 0) {
        Write-Host "Ungültiges Alter"
        return  # Funktion beenden
    }
    
    if ($alter -lt 18) {
        return "Minderjährig"
    } elseif ($alter -lt 65) {
        return "Erwachsen"
    } else {
        return "Senior"
    }
}

$status = Pruefe-Alter -alter 25
Write-Host $status  # Erwachsen

Break mit Labels (verschachtelte Schleifen)

[Bearbeiten | Quelltext bearbeiten]
# Break bricht nur innerste Schleife ab
for ($i = 1; $i -le 3; $i++) {
    for ($j = 1; $j -le 3; $j++) {
        if ($j -eq 2) {
            break  # Bricht nur innere Schleife ab
        }
        Write-Host "i=$i, j=$j"
    }
}

# Mit Label: Äußere Schleife abbrechen
:outer for ($i = 1; $i -le 3; $i++) {
    for ($j = 1; $j -le 3; $j++) {
        if ($j -eq 2) {
            break outer  # Bricht äußere Schleife ab
        }
        Write-Host "i=$i, j=$j"
    }
}
⚠️
Warnung
Verwende Labels sparsam! Sie können Code schwer lesbar machen.

Praktische Übungen

[Bearbeiten | Quelltext bearbeiten]

Übung 1: Notenbewertung

[Bearbeiten | Quelltext bearbeiten]

Aufgabe: Schreibe ein Skript, das:

  1. Eine Punktzahl von 0-100 abfragt
  2. Die Note berechnet (90-100=A, 80-89=B, 70-79=C, 60-69=D, <60=F)
  3. Prüft, ob bestanden wurde (>=60)
  4. Das Ergebnis ausgibt

Lösung anzeigen

$punkte = Read-Host "Gib deine Punktzahl ein (0-100)"
$punkte = [int]$punkte

# Validierung
if ($punkte -lt 0 -or $punkte -gt 100) {
    Write-Host "Ungültige Punktzahl! Muss zwischen 0 und 100 sein."
    return
}

# Note berechnen
if ($punkte -ge 90) {
    $note = "A"
    $text = "Sehr gut!"
} elseif ($punkte -ge 80) {
    $note = "B"
    $text = "Gut"
} elseif ($punkte -ge 70) {
    $note = "C"
    $text = "Befriedigend"
} elseif ($punkte -ge 60) {
    $note = "D"
    $text = "Ausreichend"
} else {
    $note = "F"
    $text = "Nicht bestanden"
}

# Ausgabe
Write-Host "`n=== Ergebnis ==="
Write-Host "Punkte: $punkte"
Write-Host "Note: $note"
Write-Host "Bewertung: $text"

if ($punkte -ge 60) {
    Write-Host "Status: BESTANDEN ✓" -ForegroundColor Green
} else {
    Write-Host "Status: NICHT BESTANDEN ✗" -ForegroundColor Red
}

Übung 2: Zahlenraten-Spiel

[Bearbeiten | Quelltext bearbeiten]

Aufgabe: Erstelle ein Spiel, das:

  1. Eine Zufallszahl zwischen 1 und 100 generiert
  2. Den Benutzer raten lässt
  3. "Zu hoch" oder "Zu niedrig" ausgibt
  4. Die Anzahl der Versuche zählt
  5. Bei richtigem Raten gratuliert

Lösung anzeigen

# Zufallszahl generieren
$zielZahl = Get-Random -Minimum 1 -Maximum 101
$versuche = 0
$erraten = $false

Write-Host "=== Zahlenraten-Spiel ==="
Write-Host "Ich habe mir eine Zahl zwischen 1 und 100ausgedacht."
Write-Host "Kannst du sie erraten?`n"

while (-not $erraten) {
    $versuche++
    $eingabe = Read-Host "Versuch $versuche - Dein Tipp"
    $tipp = [int]$eingabe
    
    if ($tipp -eq $zielZahl) {
        $erraten = $true
        Write-Host "`n🎉 Glückwunsch! Du hast die Zahl erraten!" -ForegroundColor Green
        Write-Host "Anzahl Versuche: $versuche"
        
        # Bewertung
        if ($versuche -le 5) {
            Write-Host "Ausgezeichnet! Du bist ein Profi!" -ForegroundColor Yellow
        } elseif ($versuche -le 10) {
            Write-Host "Gut gemacht!" -ForegroundColor Yellow
        } else {
            Write-Host "Geschafft, aber da geht noch was!" -ForegroundColor Yellow
        }
    } elseif ($tipp -lt $zielZahl) {
        Write-Host "Zu niedrig! Versuche eine höhere Zahl." -ForegroundColor Cyan
    } else {
        Write-Host "Zu hoch! Versuche eine niedrigere Zahl." -ForegroundColor Cyan
    }
}

Übung 3: Passwort-Validator

[Bearbeiten | Quelltext bearbeiten]

Aufgabe: Schreibe einen Passwort-Validator, der prüft:

  1. Mindestens 8 Zeichen lang
  2. Enthält Großbuchstaben
  3. Enthält Kleinbuchstaben
  4. Enthält Zahlen
  5. Enthält Sonderzeichen
  6. Gibt Feedback zu jedem Kriterium

Lösung anzeigen

function Test-Passwort {
    param([string]$passwort)
    
    Write-Host "`n=== Passwort-Analyse ==="
    $punkte = 0
    $maxPunkte = 5
    
    # Länge prüfen
    if ($passwort.Length -ge 8) {
        Write-Host "✓ Mindestens 8 Zeichen" -ForegroundColor Green
        $punkte++
    } else {
        Write-Host "✗ Zu kurz (mindestens 8 Zeichen)" -ForegroundColor Red
    }
    
    # Großbuchstaben
    if ($passwort -cmatch "[A-Z]") {
        Write-Host "✓ Enthält Großbuchstaben" -ForegroundColor Green
        $punkte++
    } else {
        Write-Host "✗ Keine Großbuchstaben" -ForegroundColor Red
    }
    
    # Kleinbuchstaben
    if ($passwort -cmatch "[a-z]") {
        Write-Host "✓ Enthält Kleinbuchstaben" -ForegroundColor Green
        $punkte++
    } else {
        Write-Host "✗ Keine Kleinbuchstaben" -ForegroundColor Red
    }
    
    # Zahlen
    if ($passwort -match "\d") {
        Write-Host "✓ Enthält Zahlen" -ForegroundColor Green
        $punkte++
    } else {
        Write-Host "✗ Keine Zahlen" -ForegroundColor Red
    }
    
    # Sonderzeichen
    if ($passwort -match "[^a-zA-Z0-9]") {
        Write-Host "✓ Enthält Sonderzeichen" -ForegroundColor Green
        $punkte++
    } else {
        Write-Host "✗ Keine Sonderzeichen" -ForegroundColor Red
    }
    
    # Bewertung
    Write-Host "`nBewertung: $punkte/$maxPunkte"
    
    if ($punkte -eq $maxPunkte) {
        Write-Host "Sehr sicheres Passwort! 🔒" -ForegroundColor Green
        return $true
    } elseif ($punkte -ge 3) {
        Write-Host "Akzeptables Passwort, aber verbesserungswürdig." -ForegroundColor Yellow
        return $true
    } else {
        Write-Host "Passwort zu schwach! Bitte verbessern." -ForegroundColor Red
        return $false
    }
}

# Test
$passwort = Read-Host "Gib ein Passwort ein"
Test-Passwort -passwort $passwort

Übung 4: FizzBuzz

[Bearbeiten | Quelltext bearbeiten]

Aufgabe: Implementiere das klassische FizzBuzz-Problem:

  1. Zähle von 1 bis 100
  2. Bei Vielfachen von 3: Gib "Fizz" aus
  3. Bei Vielfachen von 5: Gib "Buzz" aus
  4. Bei Vielfachen von 3 UND 5: Gib "FizzBuzz" aus
  5. Sonst: Gib die Zahl aus

Lösung anzeigen

# Lösung 1: Mit If-Else
for ($i = 1; $i -le 100; $i++) {
    if (($i % 3 -eq 0) -and ($i % 5 -eq 0)) {
        Write-Host "FizzBuzz"
    } elseif ($i % 3 -eq 0) {
        Write-Host "Fizz"
    } elseif ($i % 5 -eq 0) {
        Write-Host "Buzz"
    } else {
        Write-Host $i
    }
}

# Lösung 2: Mit String-Konkatenation (eleganter)
for ($i = 1; $i -le 100; $i++) {
    $ausgabe = ""
    
    if ($i % 3 -eq 0) { $ausgabe += "Fizz" }
    if ($i % 5 -eq 0) { $ausgabe += "Buzz" }
    
    if ($ausgabe -eq "") {
        Write-Host $i
    } else {
        Write-Host $ausgabe
    }
}

# Lösung 3: Einzeiler (PowerShell 7+)
1..100 | ForEach-Object {
    $_ % 15 ? ($_ % 3 ? ($_ % 5 ? $_ : "Buzz") : "Fizz") : "FizzBuzz"
}

Übung 5: Datei-Organisator

[Bearbeiten | Quelltext bearbeiten]

Aufgabe: Erstelle ein Skript, das:

  1. Dateien in einem Ordner nach Erweiterung gruppiert
  2. Für jeden Dateityp einen Unterordner erstellt
  3. Die Dateien in die entsprechenden Ordner verschiebt
  4. Einen Bericht über die Aktionen erstellt

Lösung anzeigen

function Organize-Files {
    param(
        [string]$quellOrdner = "$env:USERPROFILE\Downloads"
    )
    
    Write-Host "=== Datei-Organisator ==="
    Write-Host "Ordner: $quellOrdner`n"
    
    # Dateien holen
    $dateien = Get-ChildItem -Path $quellOrdner -File
    
    if ($dateien.Count -eq 0) {
        Write-Host "Keine Dateien gefunden."
        return
    }
    
    # Nach Erweiterung gruppieren
    $gruppen = $dateien | Group-Object Extension
    
    $verschoben = 0
    
    foreach ($gruppe in $gruppen) {
        # Ordnername bestimmen
        $erweiterung = $gruppe.Name
        if ($erweiterung -eq "") {
            $ordnerName = "Ohne_Erweiterung"
        } else {
            $ordnerName = $erweiterung.TrimStart('.')
        }
        
        $zielOrdner = Join-Path $quellOrdner $ordnerName
        
        # Ordner erstellen falls nicht vorhanden
        if (-not (Test-Path $zielOrdner)) {
            New-Item -Path $zielOrdner -ItemType Directory | Out-Null
            Write-Host "✓ Ordner erstellt: $ordnerName" -ForegroundColor Green
        }
        
        # Dateien verschieben
        Write-Host "`nVerschiebe $($gruppe.Count) Datei(en) nach $ordnerName :"
        
        foreach ($datei in $gruppe.Group) {
            try {
                Move-Item -Path $datei.FullName -Destination $zielOrdner -Force
                Write-Host "  → $($datei.Name)" -ForegroundColor Cyan
                $verschoben++
            } catch {
                Write-Host "  ✗ Fehler bei: $($datei.Name)" -ForegroundColor Red
            }
        }
    }
    
    # Zusammenfassung
    Write-Host "`n=== Zusammenfassung ==="
    Write-Host "Dateitypen: $($gruppen.Count)"
    Write-Host "Dateien verschoben: $verschoben"
    Write-Host "Fertig!" -ForegroundColor Green
}

# WhatIf-Modus zum Testen (ohne tatsächliches Verschieben)
# Organize-Files -WhatIf

# Ausführen
Organize-Files

Übung 6: Primzahlen-Finder

[Bearbeiten | Quelltext bearbeiten]

Aufgabe: Schreibe ein Skript, das:

  1. Alle Primzahlen bis zu einer Obergrenze findet
  2. Die Anzahl der gefundenen Primzahlen zählt
  3. Optional die Primzahlen ausgibt
  4. Die Berechnungszeit misst

Lösung anzeigen

function Find-Primzahlen {
    param(
        [int]$obergrenze = 100,
        [switch]$anzeigen
    )
    
    Write-Host "=== Primzahlen-Finder ==="
    Write-Host "Suche Primzahlen bis $obergrenze`n"
    
    # Zeit messen
    $start = Get-Date
    
    $primzahlen = @()
    
    # Spezialfall: 2 ist die einzige gerade Primzahl
    if ($obergrenze -ge 2) {
        $primzahlen += 2
    }
    
    # Nur ungerade Zahlen ab 3 prüfen
    for ($zahl = 3; $zahl -le $obergrenze; $zahl += 2) {
        $istPrimzahl = $true
        
        # Prüfen bis Wurzel der Zahl
        $grenze = [math]::Sqrt($zahl)
        
        for ($teiler = 3; $teiler -le $grenze; $teiler += 2) {
            if ($zahl % $teiler -eq 0) {
                $istPrimzahl = $false
                break
            }
        }
        
        if ($istPrimzahl) {
            $primzahlen += $zahl
        }
    }
    
    $ende = Get-Date
    $dauer = ($ende - $start).TotalMilliseconds
    
    # Ausgabe
    Write-Host "Gefundene Primzahlen: $($primzahlen.Count)"
    Write-Host "Berechnungszeit: $([math]::Round($dauer, 2)) ms`n"
    
    if ($anzeigen) {
        Write-Host "Primzahlen:"
        $primzahlen -join ', '
    }
    
    return $primzahlen
}

# Ausführen
$prims = Find-Primzahlen -obergrenze 1000 -anzeigen

Zusammenfassung

[Bearbeiten | Quelltext bearbeiten]

In diesem Kurs hast du gelernt:

✓ Vergleichsoperatoren (-eq, -ne, -gt, -lt, -like, -match) ✓ Logische Operatoren (-and, -or, -not) ✓ If-Else-Anweisungen für Entscheidungen ✓ Switch-Anweisungen für mehrere Fälle ✓ For-Schleifen für definierte Iterationen ✓ ForEach-Schleifen für Collections ✓ While und Do-While für bedingte Wiederholungen ✓ Break, Continue und Return zur Flusssteuerung

Wichtige Konzepte aus Kurs 4

[Bearbeiten | Quelltext bearbeiten]
Konzept Syntax Verwendung
If-Else if ($bedingung) {...} Bedingte Ausführung
Switch switch ($wert) {...} Mehrere Fälle
For for ($i=0; $i<10; $i++) Zähler-Schleife
ForEach foreach ($item in $array) Collection durchlaufen
While while ($bedingung) Wiederholung mit Vorbedingung
Do-While do {...} while ($bedingung) Mind. 1x ausführen
Break break Schleife abbrechen
Continue continue Iteration überspringen

Entscheidungsbaum: Welche Struktur?

[Bearbeiten | Quelltext bearbeiten]
Brauche ich eine Entscheidung?
├─ Ja, eine einfache Bedingung
│  └─ If-Else
├─ Ja, viele mögliche Werte
│  └─ Switch
└─ Nein, Wiederholung
   ├─ Weiß ich die Anzahl?
   │  ├─ Ja → For-Schleife
   │  └─ Nein
   │     ├─ Habe ich eine Collection? → ForEach
   │     └─ Bedingungsabhängig? → While/Do-While
   └─ Über Pipeline? → ForEach-Object

DO:

  • Verwende aussagekräftige Bedingungen
  • Halte Verschachtelungen flach (max. 2-3 Ebenen)
  • Nutze Switch bei mehr als 3 If-ElseIf
  • Verwende ForEach für Arrays, ForEach-Object für Pipelines
  • Break/Continue sparsam und nur wenn nötig
  • Kommentiere komplexe Bedingungen

DON'T:

  • Keine tief verschachtelten If-Anweisungen
  • Nicht zu viele Bedingungen in einer Zeile
  • Keine unendlichen Schleifen ohne Exit-Bedingung
  • Nicht Continue/Break ohne guten Grund
  • Keine For-Schleife, wenn ForEach einfacher ist
  • Nicht Vergleichsoperatoren vergessen (-eq statt =)

Cheat Sheet - Kontrollstrukturen

[Bearbeiten | Quelltext bearbeiten]
# IF-ELSE
if ($a -gt 5) {
    Write-Host "Größer als 5"
} elseif ($a -eq 5) {
    Write-Host "Genau 5"
} else {
    Write-Host "Kleiner als 5"
}

# SWITCH
switch ($wert) {
    1 { "Eins" }
    2 { "Zwei" }
    default { "Andere" }
}

# FOR
for ($i = 0; $i -lt 10; $i++) {
    Write-Host $i
}

# FOREACH
foreach ($item in $array) {
    Write-Host $item
}

# WHILE
while ($bedingung) {
    # Code
}

# DO-WHILE
do {
    # Code
} while ($bedingung)

# DO-UNTIL
do {
    # Code
} until ($bedingung)

# BREAK/CONTINUE
for ($i = 0; $i -lt 10; $i++) {
    if ($i -eq 3) { continue }  # Überspringen
    if ($i -eq 7) { break }     # Abbrechen
    Write-Host $i
}

Häufige Muster

[Bearbeiten | Quelltext bearbeiten]
# Eingabe validieren
do {
    $eingabe = Read-Host "Zahl (1-10)"
    $zahl = $eingabe -as [int]
} while ($null -eq $zahl -or $zahl -lt 1 -or $zahl -gt 10)

# Menü-System
$beenden = $false
while (-not $beenden) {
    $auswahl = Show-Menu
    switch ($auswahl) {
        1 { Do-Something }
        "q" { $beenden = $true }
    }
}

# Datei verarbeiten bis Bedingung erfüllt
$zeile = 0
Get-Content datei.txt | ForEach-Object {
    $zeile++
    if ($_ -match "ERROR") {
        Write-Host "Fehler in Zeile $zeile"
        return  # Stoppt bei erstem Fehler
    }
}

# Retry-Logik
$maxVersuche = 3
$versuch = 0
$erfolg = $false

while (($versuch -lt $maxVersuche) -and (-not $erfolg)) {
    $versuch++
    try {
        # Versuch
        $erfolg = $true
    } catch {
        if ($versuch -eq $maxVersuche) {
            throw "Fehlgeschlagen nach $maxVersuche Versuchen"
        }
        Start-Sleep -Seconds 2
    }
}

Nächste Schritte

[Bearbeiten | Quelltext bearbeiten]

Im nächsten Kurs lernst du:

  • Eigene Funktionen schreiben
  • Parameter definieren und validieren
  • Wiederverwendbare Code-Module erstellen
  • Skripte strukturieren und organisieren
  • Best Practices für Funktionen

Zusätzliche Ressourcen

[Bearbeiten | Quelltext bearbeiten]

Praktische Beispiele aus der Praxis

[Bearbeiten | Quelltext bearbeiten]
# 1. Service-Überwachung mit Neustart
$dienste = @("Spooler", "W32Time", "wuauserv")

foreach ($dienst in $dienste) {
    $service = Get-Service -Name $dienst -ErrorAction SilentlyContinue
    
    if ($null -eq $service) {
        Write-Host "Dienst $dienst existiert nicht" -ForegroundColor Yellow
        continue
    }
    
    if ($service.Status -ne 'Running') {
        Write-Host "Starte $dienst..." -ForegroundColor Cyan
        try {
            Start-Service -Name $dienst
            Write-Host "✓ $dienst gestartet" -ForegroundColor Green
        } catch {
            Write-Host "✗ Fehler beim Starten von $dienst" -ForegroundColor Red
        }
    } else {
        Write-Host "✓ $dienst läuft bereits" -ForegroundColor Green
    }
}

# 2. Festplatten-Monitor
$laufwerke = Get-PSDrive -PSProvider FileSystem | Where-Object {$_.Used -gt 0}

foreach ($laufwerk in $laufwerke) {
    $prozent = ($laufwerk.Used / ($laufwerk.Used + $laufwerk.Free)) * 100
    $prozent = [math]::Round($prozent, 2)
    
    Write-Host "`nLaufwerk $($laufwerk.Name):"
    Write-Host "  Belegt: $prozent%"
    
    if ($prozent -gt 90) {
        Write-Host "  ⚠ KRITISCH - Zu wenig Speicher!" -ForegroundColor Red
    } elseif ($prozent -gt 75) {
        Write-Host "  ⚡ WARNUNG - Speicher wird knapp" -ForegroundColor Yellow
    } else {
        Write-Host "  ✓ OK" -ForegroundColor Green
    }
}

# 3. Backup-Skript mit Rotation
$quellOrdner = "C:\Daten"
$backupOrdner = "D:\Backups"
$maxBackups = 5

# Datum für Backup-Namen
$datum = Get-Date -Format "yyyy-MM-dd_HHmmss"
$backupName = "Backup_$datum"
$zielPfad = Join-Path $backupOrdner $backupName

# Backup erstellen
Write-Host "Erstelle Backup: $backupName"
Copy-Item -Path $quellOrdner -Destination $zielPfad -Recurse

# Alte Backups löschen
$backups = Get-ChildItem $backupOrdner | 
           Where-Object {$_.Name -like "Backup_*"} |
           Sort-Object CreationTime -Descending

if ($backups.Count -gt $maxBackups) {
    $zuLoeschen = $backups | Select-Object -Skip $maxBackups
    
    foreach ($backup in $zuLoeschen) {
        Write-Host "Lösche altes Backup: $($backup.Name)"
        Remove-Item $backup.FullName -Recurse -Force
    }
}

# 4. Log-Datei-Analyzer
$logDatei = "C:\Logs\application.log"
$fehlerKeywords = @("ERROR", "CRITICAL", "FATAL")

$statistik = @{
    GesZeilen = 0
    Fehler = 0
    Warnungen = 0
}

Get-Content $logDatei | ForEach-Object {
    $statistik.GesZeilen++
    
    $zeile = $_
    
    # Fehler prüfen
    foreach ($keyword in $fehlerKeywords) {
        if ($zeile -match $keyword) {
            $statistik.Fehler++
            Write-Host "FEHLER: $zeile" -ForegroundColor Red
            break
        }
    }
    
    # Warnungen
    if ($zeile -match "WARN") {
        $statistik.Warnungen++
    }
}

Write-Host "`n=== Log-Statistik ==="
Write-Host "Zeilen gesamt: $($statistik.GesZeilen)"
Write-Host "Fehler: $($statistik.Fehler)"
Write-Host "Warnungen: $($statistik.Warnungen)"

# 5. Netzwerk-Scanner
$subnet = "192.168.1"
$bereich = 1..254
$online = @()

Write-Host "Scanne Netzwerk $subnet.0/24..."

foreach ($ip in $bereich) {
    $adresse = "$subnet.$ip"
    
    if (Test-Connection -ComputerName $adresse -Count 1 -Quiet -TimeoutSeconds 1) {
        Write-Host "✓ $adresse ist erreichbar" -ForegroundColor Green
        $online += $adresse
    }
    
    # Fortschritt
    if ($ip % 50 -eq 0) {
        Write-Host "Fortschritt: $ip/254"
    }
}

Write-Host "`nGefundene Hosts: $($online.Count)"
$online
✓
Erfolg
Glückwunsch! Du hast Kurs 4 abgeschlossen und kannst jetzt Kontrollstrukturen effektiv einsetzen!