Powershell - Kontrollstrukturen
Kursübersicht
[Bearbeiten | Quelltext bearbeiten]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
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
[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!"
}
If-Else
[Bearbeiten | Quelltext bearbeiten]$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
}
If-ElseIf-Else
[Bearbeiten | Quelltext bearbeiten]$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" }
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
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"
}
foreach-Anweisung für Arrays/Collections, ForEach-Object für Pipeline-Verarbeitung.Modul 4.6: While und Do-While
[Bearbeiten | Quelltext bearbeiten]While-Schleife
[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
[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
[Bearbeiten | Quelltext bearbeiten]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
[Bearbeiten | Quelltext bearbeiten]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"
}
}
Praktische Übungen
[Bearbeiten | Quelltext bearbeiten]Übung 1: Notenbewertung
[Bearbeiten | Quelltext bearbeiten]Aufgabe: Schreibe ein Skript, das:
- Eine Punktzahl von 0-100 abfragt
- Die Note berechnet (90-100=A, 80-89=B, 70-79=C, 60-69=D, <60=F)
- Prüft, ob bestanden wurde (>=60)
- 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:
- Eine Zufallszahl zwischen 1 und 100 generiert
- Den Benutzer raten lässt
- "Zu hoch" oder "Zu niedrig" ausgibt
- Die Anzahl der Versuche zählt
- 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:
- Mindestens 8 Zeichen lang
- Enthält Großbuchstaben
- Enthält Kleinbuchstaben
- Enthält Zahlen
- Enthält Sonderzeichen
- 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:
- Zähle von 1 bis 100
- Bei Vielfachen von 3: Gib "Fizz" aus
- Bei Vielfachen von 5: Gib "Buzz" aus
- Bei Vielfachen von 3 UND 5: Gib "FizzBuzz" aus
- 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:
- Dateien in einem Ordner nach Erweiterung gruppiert
- Für jeden Dateityp einen Unterordner erstellt
- Die Dateien in die entsprechenden Ordner verschiebt
- 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:
- Alle Primzahlen bis zu einer Obergrenze findet
- Die Anzahl der gefundenen Primzahlen zählt
- Optional die Primzahlen ausgibt
- 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-ObjectBest Practices
[Bearbeiten | Quelltext bearbeiten]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