Powershell

• Grundlagen
• Thema 0 - Powershell Wissen
• Grundlagen - Operatoren
• Grundlagen Zusammenfassung
• PowerShell – Parameter
• PowerShell – Eigene Parameter definieren
• Powershell Trainer
• Trainer 01 – Basics bis Schleifen
• Trainer 02 – Grundlagen
• Trainer 03 – Bedingungen und Schleifen
• Trainer 04 - Schleifen
• Trainer 05 - Schleifenlogik verstehen
• Trainer 06 – Do-While und Until
• PowerShell – Schleifen kompakt erklärt
• PowerShell Schleifen – Zusatz
• PowerShell Trainer – Benannte Parameter und Parameter-Dekorator
• PowerShell Trainer – Fragen und Antworten zu Parametern

Grundlagen

Thema 0 - Powershell Wissen

Powershell

ist eine lose typisierte Programmiersprache und arbeitet mit implizierten Konvertierungen

Skriptsprache:  eine Programmiersprache die für Skripte verwendet wird, arbeitet mit meist nach dem Stapelverarbeitungsmodus und ist meist in interpritiert. (Interpreter)

Grundlagen - Operatoren

PowerShell – Grundlagen: Operatoren

Überblick

Operatoren in PowerShell werden verwendet für:

• Vergleiche
• String-Suche
• Listenprüfungen
• Berechnungen
• Zuweisungen

Vergleichsoperatoren

-eq   # gleich (equal)
-ne   # ungleich (not equal)
-gt   # größer als (greater than)
-lt   # kleiner als (less than)
-ge   # größer gleich (greater equal)
-le   # kleiner gleich (less equal)

Clear-Host

"Apfel" -eq "Birne"
"Apfel" -ceq "apfel"   # case sensitive Vergleich

12 -eq 12   # true
12 -ne 15   # true
12 -gt 9    # true
12 -lt 9    # false
12 -ge 11   # true
12 -le 12   # true

"Apfel" -lt "Birne"   # alphabetischer Vergleich

Grundlagen Zusammenfassung

Variablen & Strings

• Variablen starten mit $ und werden mit = gesetzt → $x = 5 (Typ automatisch)
• Zugriff immer mit $
• "..." → Variable wird ersetzt (ausgewertet) → "Wert: $x" → Wert: 5
• '...' → Variable bleibt Text → 'Wert: $x' → Wert: $x
• = → Zuweisung | Vergleich z. B. mit -eq

👉 Merksatz:
Doppelte Anführungszeichen = Wert wird eingesetzt
Einfache Anführungszeichen = bleibt nur Text

Datentypen

• PowerShell ist dynamisch typisiert → Typ wird automatisch erkannt ($x = 5, $y = "Text")
• Häufige Typen: String ("Text"), Int (5), Double (3.14), Boolean ($true/$false), Array (1,2,3)
• Typ kann explizit gesetzt werden → [int]$x = 5, [string]$name = "Derick"
• Typ prüfen → $x.GetType()

👉 Wichtig:

• Rechnen nur mit Zahlen sinnvoll ("5" + 5 → kann unerwartet sein)
• Arrays werden mit Komma erstellt → $arr = 1,2,3

👉 Merksatz:
Typ kommt automatisch – kann aber festgelegt werden

• Ausgabe →
  • Write-Host "Text" (nur Anzeige, nicht weiter nutzbar)
  • Write-Output "Text" oder "Text" (empfohlen, weiterverarbeitbar)
• Eingabe → $x = Read-Host "Frage"
• Datum → Get-Date
• Konsole löschen → Clear-Host / cls (beides leert die Konsole)

# Ausgabe 'Write-Output'

# Variante 1 (offiziell)
Write-Output "Hallo"   # → Ausgabe: Hallo

# Variante 2 (Kurzform)
"Hallo"                # → Ausgabe: Hallo

# Konsole löschen 'cls'

# Variante 1 (voller Befehl)
Clear-Host             # → Konsole wird geleert

# Variante 2 (Kurzform / Alias)
cls                    # → Konsole wird geleert

👉 Merksatz: Write-Output besser als Write-Host | Read-Host Input einlesen | Cls entspricht Clear-Host

Rechnen

• Grundrechenarten → + - * /
• Beispiele → $x = 5 + 3 | $y = 10 - 2 | $z = 4 * 2 | $a = 8 / 2
• Punkt vor Strich gilt → $r = 2 + 3 * 4 → Ergebnis: 14
• Klammern steuern Reihenfolge → $r = (2 + 3) * 4 → Ergebnis: 20
• Zuweisung kombiniert → $x += 5 (gleich $x = $x + 5)

# Variante 1 (lang)
$x = $x + 5   # → erhöht $x um 5

# Variante 2 (kurz)
$x += 5       # → erhöht $x um 5

👉 Merksatz: Operatoren wie Mathe | Reihenfolge beachten | Klammern nutzen

Operatoren

• Vergleich → -eq -ne -gt -lt → vergleichen Werte (True/False)
• Rechnen → + - * /
• Zuweisung → = +=
• String → -like (Wildcard) | -match (Regex)
• Listen → -contains (Liste enthält Wert) | -in (Wert in Liste)
• Logisch → -and -or -not
• Zusatz → -not (verneint) | -c (case-sensitive, z. B. -ceq)

# Vergleich
5 -eq 5        # → True
5 -gt 3        # → True

# Rechnen
2 + 3          # → 5

# Zuweisung
$x = 5
$x += 2        # → 7

# String
"Test" -like "T*"    # → True
"Test" -match "es"   # → True

# Listen
1,2,3 -contains 2    # → True
2 -in 1,2,3          # → True

# Logisch
($true -and $false)  # → False

# Zusatz
5 -ne 3              # → True
"Test" -ceq "test"   # → False (Groß/Klein beachten)

PowerShell Verzweigungen (kurz & knapp)

• if / else → führt Code je nach Bedingung aus
• switch → prüft eine Variable gegen mehrere Fälle (übersichtlicher als viele ifs)

# if / else
$x = 10

if ($x -gt 5) {
    "größer als 5"
} else {
    "kleiner oder gleich 5"
}

# switch
$farbe = "rot"

switch ($farbe) {
    "rot"   { "Stop" }
    "grün"  { "Go" }
    default { "Unbekannt" }
}

👉 Merksatz: if = einfache Entscheidung | switch = viele Fälle übersichtlich

PowerShell – Parameter

Grundidee

Parameter sind Zusatzangaben zu einem PowerShell-Befehl.

Mit Parametern legt man fest, was genau ein Cmdlet tun soll oder wie es arbeiten soll.

Ein PowerShell-Befehl besteht meistens aus:

Beispiel:

Get-Process -Name "notepad"

Bedeutung:

PowerShell zeigt dadurch nicht alle Prozesse an, sondern nur den Prozess mit dem Namen notepad.

Merksatz

Cmdlet = Was soll passieren?
Parameter = Wie genau soll es passieren?
Parameterwert = Womit oder worauf soll es passieren?

Typischer Aufbau

Ein PowerShell-Befehl mit Parameter hat meistens diesen Aufbau:

Cmdlet -Parameter Wert

Beispiel:

Get-Service -Name "Spooler"

Bedeutung:

Warum Parameter wichtig sind

Ohne Parameter führt ein Cmdlet oft eine allgemeine Aktion aus.

Beispiel:

Get-Service

Dieser Befehl zeigt viele Dienste an.

Mit Parameter wird die Ausgabe gezielter:

Get-Service -Name "Spooler"

Jetzt wird nur der Dienst Spooler angezeigt.

Parameter helfen also dabei, Befehle genauer, sicherer und gezielter auszuführen.

Parameter mit Wert

Viele Parameter benötigen einen Wert.

Beispiel:

Get-ChildItem -Path "C:\Temp"

Hier braucht der Parameter -Path einen konkreten Pfad.

Weitere Beispiele:

Get-Process -Name "notepad"

Get-Service -Name "Spooler"

Get-ChildItem -Filter "*.txt"

Typische Parameter mit Wert:

Schalterparameter

Ein Schalterparameter braucht keinen eigenen Wert.

Er ist aktiv, sobald man ihn angibt.

Beispiel:

Get-ChildItem -Recurse

Der Parameter -Recurse bedeutet, dass auch Unterordner durchsucht werden.

Weitere Beispiele:

Remove-Item "C:\Temp\test.txt" -Force

Get-ChildItem -Hidden

Stop-Process -Name "notepad" -Force

Typische Schalterparameter:

Wichtige Sicherheitsparameter

Besonders wichtig sind -WhatIf und -Confirm.

Diese Parameter helfen, gefährliche Aktionen zu prüfen.

Beispiel:

Remove-Item "C:\Temp\test.txt" -WhatIf

PowerShell zeigt nur an, was gelöscht werden würde.
Die Datei wird nicht wirklich gelöscht.

Beispiel mit Bestätigung:

Remove-Item "C:\Temp\test.txt" -Confirm

PowerShell fragt vor dem Löschen nach.

Das ist besonders wichtig bei Befehlen wie:

Positionelle Parameter

Manche Parameter müssen nicht ausgeschrieben werden, weil PowerShell anhand der Position erkennt, welcher Parameter gemeint ist.

Beispiel mit ausgeschriebenem Parameter:

Get-ChildItem -Path "C:\Temp"

Kurzform:

Get-ChildItem "C:\Temp"

PowerShell erkennt hier, dass "C:\Temp" der Wert für -Path ist.

Für die Prüfung und für saubere Dokumentation ist die ausgeschriebene Variante besser:

Get-ChildItem -Path "C:\Temp"

Sie ist klarer und leichter nachvollziehbar.

Mehrere Parameter kombinieren

Ein Cmdlet kann mehrere Parameter gleichzeitig verwenden.

Beispiel:

Get-ChildItem -Path "C:\Temp" -Filter "*.txt" -Recurse

Bedeutung:

Der Befehl sucht also im Ordner C:\Temp und allen Unterordnern nach Dateien mit der Endung .txt.

Parameter und Datentypen

Parameter erwarten oft bestimmte Datentypen.

Beispiele:

Beispiel mit mehreren Namen:

Get-Service -Name "Spooler","WinRM"

Hier bekommt der Parameter -Name mehrere Werte.

Parameter und Anführungszeichen

Texte mit Leerzeichen sollten in Anführungszeichen geschrieben werden.

Beispiel:

Get-ChildItem -Path "C:\Meine Dateien"

Ohne Anführungszeichen könnte PowerShell den Pfad falsch interpretieren.

Bei einfachen Werten ohne Leerzeichen sind Anführungszeichen oft nicht zwingend nötig:

Get-Service -Name Spooler

Trotzdem ist es beim Lernen oft übersichtlicher, Zeichenketten mit Anführungszeichen zu schreiben.

Parameter mit Wildcards

Viele Parameter unterstützen Platzhalterzeichen.

Das wichtigste Platzhalterzeichen ist:

Beispiel:

Get-Service -Name "Win*"

Zeigt Dienste an, deren Name mit Win beginnt.

Beispiel:

Get-ChildItem -Path "C:\Temp" -Filter "*.txt"

Zeigt alle Dateien mit der Endung .txt an.

Pflichtparameter

Manche Parameter sind erforderlich.

Wenn ein Pflichtparameter fehlt, fragt PowerShell nach dem fehlenden Wert.

Beispiel:

Read-Host -Prompt

PowerShell erwartet hier einen Wert für -Prompt.

Besser:

Read-Host -Prompt "Bitte Namen eingeben"

Optionale Parameter

Viele Parameter sind optional.

Beispiel:

Get-Process

Dieser Befehl funktioniert ohne weitere Parameter.

Mit optionalem Parameter wird er genauer:

Get-Process -Name "notepad"

Der Parameter -Name ist hier nicht zwingend notwendig, aber nützlich.

Parameter und Pipeline

PowerShell arbeitet objektorientiert.
Die Pipeline übergibt nicht nur Text, sondern Objekte von einem Befehl zum nächsten.

Beispiel:

Get-Process -Name "notepad" | Stop-Process

Bedeutung:

Noch deutlicher:

Get-Process -Name "notepad" | Stop-Process -Force

Hier beendet PowerShell den Prozess notepad erzwungen.

Pipeline-Parameter

Einige Parameter können Werte aus der Pipeline annehmen.

Beispiel:

Get-Service -Name "Spooler" | Stop-Service

Der Dienst wird zuerst gesucht und dann an Stop-Service weitergegeben.

PowerShell erkennt anhand des Objekttyps, welcher Parameter des nächsten Cmdlets den Wert annehmen kann.

Das nennt man auch:

Für die IHK reicht meistens das Grundverständnis:

Die Pipeline übergibt das Ergebnis eines Befehls an den nächsten Befehl. Parameter können diese übergebenen Werte weiterverarbeiten.

Common Parameters

Viele PowerShell-Cmdlets besitzen gemeinsame Standardparameter.

Diese nennt man Common Parameters.

Wichtige Beispiele:

Beispiel:

Get-Service -Name "Spooler" -Verbose

Mit -Verbose können zusätzliche Informationen angezeigt werden.

Fehlerbehandlung mit Parametern

Ein wichtiger Parameter ist -ErrorAction.

Damit legt man fest, wie PowerShell bei Fehlern reagieren soll.

Beispiel:

Get-Item -Path "C:\NichtVorhanden" -ErrorAction SilentlyContinue

Bedeutung:

PowerShell gibt keinen sichtbaren Fehler aus, wenn der Pfad nicht existiert.

Häufige Werte für -ErrorAction:

Parameter herausfinden

Man muss nicht alle Parameter auswendig kennen.

PowerShell bietet Hilfe-Befehle.

Wichtige Befehle:

Get-Help Get-ChildItem

Zeigt Hilfe zum Cmdlet an.

Get-Help Get-ChildItem -Detailed

Zeigt ausführlichere Informationen.

Get-Help Get-ChildItem -Examples

Zeigt Beispiele.

Get-Command Get-ChildItem -Syntax

Zeigt die Syntax des Cmdlets.

Get-Command Get-ChildItem | Select-Object -ExpandProperty Parameters

Zeigt die verfügbaren Parameter eines Cmdlets.

Syntax in der Hilfe verstehen

Bei PowerShell-Hilfeausgaben sieht man oft eckige Klammern.

Beispiel:

Get-ChildItem [[-Path] <string[]>] [-Filter <string>] [-Recurse]

Bedeutung:

Wichtig:

Eckige Klammern bedeuten in der Syntax meistens: optional.

Cmdlet-Namen und Parameter

PowerShell-Cmdlets folgen meistens dem Verb-Nomen-Schema.

Beispiele:

Parameter passen sich an das jeweilige Cmdlet an.

Beispiel:

Get-Service -Name "Spooler"

Stop-Service -Name "Spooler"

Beide Befehle nutzen -Name, aber mit unterschiedlicher Aktion.

Aliase und Parameter

PowerShell besitzt auch Kurzformen, sogenannte Aliase.

Beispiele:

Beispiel:

dir "C:\Temp"

Das entspricht ungefähr:

Get-ChildItem -Path "C:\Temp"

Für die IHK und Dokumentation ist das ausgeschriebene Cmdlet besser, weil es eindeutiger ist.

Parameter in eigenen Skripten

Auch eigene PowerShell-Skripte können Parameter besitzen.

Beispiel:

param(
    [string]$Name
)

Write-Output "Hallo $Name"

Wenn das Skript zum Beispiel gruss.ps1 heißt, kann man es so starten:

.\gruss.ps1 -Name "Felix"

Ausgabe:

Hallo Felix

Mehrere eigene Parameter

Beispiel:

param(
    [string]$Name,
    [int]$Alter
)

Write-Output "$Name ist $Alter Jahre alt."

Aufruf:

.\person.ps1 -Name "Felix" -Alter 30

Hier sind:

Pflichtparameter in eigenen Skripten

Man kann Parameter als verpflichtend kennzeichnen.

Beispiel:

param(
    [Parameter(Mandatory=$true)]
    [string]$Name
)

Write-Output "Hallo $Name"

Wenn der Parameter -Name beim Start fehlt, fragt PowerShell nach.

Parameter mit Standardwert

Parameter können Standardwerte besitzen.

Beispiel:

param(
    [string]$Name = "Benutzer"
)

Write-Output "Hallo $Name"

Wenn kein Name angegeben wird, verwendet PowerShell automatisch Benutzer.

Parameter validieren

PowerShell kann Parameterwerte prüfen.

Beispiel mit erlaubten Werten:

param(
    [ValidateSet("Start","Stop","Restart")]
    [string]$Aktion
)

Write-Output "Gewählte Aktion: $Aktion"

Jetzt darf der Parameter -Aktion nur bestimmte Werte annehmen:

Beispiel:

.\dienst.ps1 -Aktion Start

Ein falscher Wert würde abgelehnt werden.

Typische IHK-relevante Beispiele

Dienst anzeigen

Get-Service -Name "Spooler"

Zeigt den Dienst Spooler an.

Dienst starten

Start-Service -Name "Spooler"

Startet den Dienst Spooler.

Dienst stoppen

Stop-Service -Name "Spooler"

Stoppt den Dienst Spooler.

Prozess anzeigen

Get-Process -Name "notepad"

Zeigt den Prozess notepad an.

Prozess beenden

Stop-Process -Name "notepad"

Beendet den Prozess notepad.

Dateien in einem Ordner anzeigen

Get-ChildItem -Path "C:\Temp"

Zeigt den Inhalt des Ordners C:\Temp an.

Dateien rekursiv suchen

Get-ChildItem -Path "C:\Temp" -Filter "*.log" -Recurse

Sucht im Ordner C:\Temp und allen Unterordnern nach .log-Dateien.

Datei löschen mit Sicherheitsprüfung

Remove-Item -Path "C:\Temp\test.txt" -WhatIf

Zeigt an, was gelöscht werden würde, löscht aber nicht wirklich.

Datei löschen mit Bestätigung

Remove-Item -Path "C:\Temp\test.txt" -Confirm

Fragt vor dem Löschen nach.

Wichtige Begriffe

Häufige Fehler

Gute Praxis

IHK-Einordnung

Für die IHK ist vor allem wichtig, dass man das Prinzip versteht.

Man muss normalerweise nicht jeden Parameter auswendig kennen.

Wichtig ist:

Prüfungsnahes Beispiel

Aufgabe:

Ein Administrator möchte alle Textdateien im Ordner C:\Temp und dessen Unterordnern anzeigen lassen.

Passender PowerShell-Befehl:

Get-ChildItem -Path "C:\Temp" -Filter "*.txt" -Recurse

Erklärung:

Prüfungsnahes Beispiel mit Sicherheit

Aufgabe:

Ein Administrator möchte prüfen, welche Dateien durch einen Löschbefehl betroffen wären, ohne sie wirklich zu löschen.

Passender PowerShell-Befehl:

Remove-Item -Path "C:\Temp\*.log" -WhatIf

Erklärung:

Zusammenfassung

Parameter sind ein zentrales Konzept in PowerShell.

Sie steuern, wie ein Cmdlet arbeitet und auf welche Objekte es angewendet wird.

Die wichtigsten Punkte:

Kurzer Merksatz

Ein Parameter ist eine Zusatzangabe zu einem PowerShell-Cmdlet, mit der festgelegt wird, worauf und wie der Befehl angewendet wird.

Beispiel:

Get-Service -Name "Spooler"

Get-Service ist das Cmdlet.
-Name ist der Parameter.
"Spooler" ist der Parameterwert.

PowerShell – Eigene Parameter definieren

Neben der Verwendung vorhandener Parameter kann man in PowerShell auch eigene Parameter für Skripte und Funktionen definieren.

Dadurch muss man Werte nicht fest im Skript eintragen, sondern kann sie beim Start des Skripts übergeben.

Warum eigene Parameter sinnvoll sind

Ohne Parameter wären Werte oft fest im Skript eingetragen.

Beispiel ohne Parameter:

$Name = "Felix"
Write-Output "Hallo $Name"

Das Problem:

Der Name ist fest im Skript eingetragen.
Wenn ein anderer Name verwendet werden soll, muss das Skript geändert werden.

Besser ist ein Parameter:

param(
    [string]$Name
)

Write-Output "Hallo $Name"

Aufruf:

.\gruss.ps1 -Name "Felix"

Ausgabe:

Hallo Felix

Der param()-Block

Eigene Parameter werden in PowerShell meistens mit einem param()-Block definiert.

Der param()-Block steht in Skripten normalerweise am Anfang der Datei.

Grundform:

param(
    [Datentyp]$Parametername
)

Beispiel:

param(
    [string]$Name
)

Write-Output "Hallo $Name"

Bedeutung:

Parameter beim Skriptstart übergeben

Ein Skript mit Parameter kann beim Start Werte annehmen.

Beispielskript:

param(
    [string]$Name,
    [int]$Alter
)

Write-Output "$Name ist $Alter Jahre alt."

Aufruf:

.\person.ps1 -Name "Felix" -Alter 30

Bedeutung:

Datentypen bei Parametern

Man kann festlegen, welchen Datentyp ein Parameter erwartet.

Beispiele:

Beispiel:

param(
    [string]$ComputerName,
    [int]$Port
)

Write-Output "Computer: $ComputerName"
Write-Output "Port: $Port"

Aufruf:

.\test.ps1 -ComputerName "Server01" -Port 443

Parameter mit Standardwert

Ein Parameter kann einen Standardwert haben.

Wenn beim Aufruf kein Wert angegeben wird, verwendet PowerShell automatisch den Standardwert.

Beispiel:

param(
    [string]$Name = "Benutzer"
)

Write-Output "Hallo $Name"

Aufruf ohne Parameter:

.\gruss.ps1

Ausgabe:

Hallo Benutzer

Aufruf mit Parameter:

.\gruss.ps1 -Name "Felix"

Ausgabe:

Hallo Felix

Pflichtparameter

Ein Parameter kann verpflichtend gemacht werden.

Dafür verwendet man das Attribut:

[Parameter(Mandatory)]

Beispiel:

param(
    [Parameter(Mandatory)]
    [string]$Name
)

Write-Output "Hallo $Name"

Wenn der Parameter beim Aufruf fehlt, fragt PowerShell nach dem Wert.

Aufruf:

.\gruss.ps1

PowerShell fragt dann nach dem fehlenden Parameter.

Parameter-Attribut

Mit [Parameter()] kann man Eigenschaften eines Parameters festlegen.

Beispiel:

param(
    [Parameter(Mandatory)]
    [string]$ComputerName
)

Wichtige Eigenschaften:

Positionelle Parameter

Parameter können auch über ihre Position übergeben werden.

Beispiel:

param(
    [Parameter(Position=0)]
    [string]$Name,

    [Parameter(Position=1)]
    [int]$Alter
)

Write-Output "$Name ist $Alter Jahre alt."

Aufruf mit Parameternamen:

.\person.ps1 -Name "Felix" -Alter 30

Aufruf über Position:

.\person.ps1 "Felix" 30

PowerShell erkennt:

Für saubere Dokumentation ist die Variante mit Parameternamen meist besser.

Parameter validieren

Parameterwerte können geprüft werden.

Dadurch kann verhindert werden, dass falsche Werte verarbeitet werden.

ValidateSet

Mit ValidateSet kann man erlaubte Werte festlegen.

Beispiel:

param(
    [ValidateSet("Start","Stop","Restart")]
    [string]$Action
)

Write-Output "Gewählte Aktion: $Action"

Erlaubte Aufrufe:

.\dienst.ps1 -Action Start

.\dienst.ps1 -Action Stop

.\dienst.ps1 -Action Restart

Nicht erlaubt:

.\dienst.ps1 -Action Delete

PowerShell würde den falschen Wert ablehnen.

ValidateNotNullOrEmpty

Mit ValidateNotNullOrEmpty wird verhindert, dass ein leerer Wert übergeben wird.

Beispiel:

param(
    [ValidateNotNullOrEmpty()]
    [string]$Name
)

Write-Output "Hallo $Name"

Das ist sinnvoll, wenn ein Parameter zwar angegeben wird, aber nicht leer sein darf.

Schalterparameter selbst definieren

Schalterparameter werden mit [switch] definiert.

Ein Schalterparameter braucht keinen eigenen Wert.

Beispiel:

param(
    [switch]$Ausfuehrlich
)

if ($Ausfuehrlich) {
    Write-Output "Ausführliche Ausgabe aktiviert"
} else {
    Write-Output "Normale Ausgabe"
}

Aufruf ohne Schalter:

.\test.ps1

Aufruf mit Schalter:

.\test.ps1 -Ausfuehrlich

Bedeutung:

Der Parameter ist aktiv, sobald er angegeben wird.

Parameter in Funktionen

Parameter können nicht nur in Skripten, sondern auch in Funktionen verwendet werden.

Beispiel:

function Begruessung {
    param(
        [string]$Name
    )

    Write-Output "Hallo $Name"
}

Aufruf:

Begruessung -Name "Felix"

Ausgabe:

Hallo Felix

Erweiterte Funktion mit Parametern

Eine etwas sauberere Funktion:

function Test-Verbindung {
    param(
        [Parameter(Mandatory)]
        [string]$ComputerName
    )

    Test-Connection -ComputerName $ComputerName -Count 2
}

Aufruf:

Test-Verbindung -ComputerName "server01"

Hier nimmt die eigene Funktion den Parameter -ComputerName entgegen und verwendet ihn intern für Test-Connection.

Unbenannte Parameter mit $args

PowerShell kann auch über $args Werte entgegennehmen.

Beispiel:

Write-Output "Erster Wert: $($args[0])"
Write-Output "Zweiter Wert: $($args[1])"

Aufruf:

.\test.ps1 Felix Berlin

Ausgabe:

Erster Wert: Felix
Zweiter Wert: Berlin

Das funktioniert, ist aber weniger sauber als ein richtiger param()-Block.

Besser:

param(
    [string]$Name,
    [string]$Ort
)

Write-Output "$Name aus $Ort"

Aufruf:

.\test.ps1 -Name "Felix" -Ort "Berlin"

Named Parameters vs. Positional Parameters

Es gibt zwei typische Arten, Parameter zu übergeben.

Named Parameters sind besser lesbar und weniger fehleranfällig.

Mehrere Werte übergeben

Ein Parameter kann mehrere Werte annehmen, wenn er als Array definiert ist.

Beispiel:

param(
    [string[]]$ComputerName
)

foreach ($Computer in $ComputerName) {
    Write-Output "Prüfe $Computer"
}

Aufruf:

.\check.ps1 -ComputerName "PC1","PC2","PC3"

Ausgabe:

Prüfe PC1
Prüfe PC2
Prüfe PC3

Advanced Function und CmdletBinding

Mit [CmdletBinding()] kann eine Funktion sich stärker wie ein echtes Cmdlet verhalten.

Beispiel:

function Remove-TestDatei {
    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter(Mandatory)]
        [string]$Path
    )

    if ($PSCmdlet.ShouldProcess($Path, "Datei löschen")) {
        Remove-Item -Path $Path
    }
}

Vorteil:

Die Funktion unterstützt dadurch zum Beispiel -WhatIf.

Aufruf:

Remove-TestDatei -Path "C:\Temp\test.txt" -WhatIf

PowerShell zeigt dann nur an, was passieren würde.

Das ist besonders wichtig bei Funktionen, die etwas verändern oder löschen.

Warum Parameter besser sind als feste Werte

Schlechter Stil:

$ComputerName = "Server01"
Test-Connection -ComputerName $ComputerName

Besser:

param(
    [string]$ComputerName
)

Test-Connection -ComputerName $ComputerName

Aufruf:

.\ping.ps1 -ComputerName "Server01"

Vorteile:

IHK-Einordnung

Für die IHK ist vor allem wichtig, das Prinzip zu verstehen:

Ein Parameter macht Skripte und Funktionen flexibel.

Man schreibt nicht alle Werte fest in den Code, sondern übergibt sie beim Aufruf.

Wichtige Punkte:

Prüfungsnahes Beispiel

Aufgabe:

Ein Skript soll einen Computernamen als Parameter entgegennehmen und eine Verbindung prüfen.

Lösung:

param(
    [Parameter(Mandatory)]
    [string]$ComputerName
)

Test-Connection -ComputerName $ComputerName -Count 2

Aufruf:

.\check.ps1 -ComputerName "Server01"

Erklärung:

Kurzer Merksatz

Mit param() definiert man eigene Parameter für PowerShell-Skripte oder Funktionen. Dadurch werden Skripte flexibel, wiederverwendbar und professioneller.

Powershell Trainer

Trainer 01 – Basics bis Schleifen

PowerShell-Trainer im Vollbild öffnen

Trainer 02 – Grundlagen

PowerShell-Trainer 02 im Vollbild öffnen

Trainer 03 – Bedingungen und Schleifen

PowerShell-Trainer 03 im Vollbild öffnen

Trainer 04 - Schleifen

Trainer im Vollbild öffnen

Trainer 05 - Schleifenlogik verstehen

Trainer im Vollbild öffnen

Trainer 06 – Do-While und Until

Vollbild öffnen

PowerShell – Schleifen kompakt erklärt

Grundidee

Eine Schleife wiederholt einen Codeblock, solange eine Bedingung erfüllt ist oder bis eine Abbruchbedingung erreicht wird.

Wichtige Schleifentypen

Abweisende Schleifen

Abweisende Schleifen prüfen die Bedingung vor dem ersten Durchlauf.

Sie können deshalb 0-mal laufen.

Beispiele:

while ($x -lt 5) {
}

for ($i = 0; $i -lt 3; $i++) {
}

foreach ($item in $liste) {
}

Nicht-abweisende / fußgesteuerte Schleifen

Diese Schleifen prüfen die Bedingung erst nach dem ersten Durchlauf.

Sie laufen deshalb mindestens 1-mal.

Beispiele:

do {
}
while ($x -lt 5)

do {
}
until ($x -ge 5)

Kopfgesteuert und fußgesteuert

Schleifenkopf

Im Schleifenkopf steht die Bedingung oder Steuerung der Schleife.

Beispiel:

while ($i -lt 5)

Schleifenkörper

Der Schleifenkörper ist der Code, der wiederholt ausgeführt wird.

Beispiel:

{
    Write-Host $i
    $i++
}

Iteration

Eine Iteration ist ein einzelner Schleifendurchlauf.

Wenn eine Schleife 5-mal läuft, hat sie 5 Iterationen.

Abbruchbedingung

Die Abbruchbedingung beschreibt, wann die Schleife beendet werden soll.

Beispiel:

Abbrechen, sobald $i mindestens 5 ist.

Bei do until steht diese Bedingung direkt in der Schleife:

do {
    $i++
}
until ($i -ge 5)

Weiterlaufbedingung

Die Weiterlaufbedingung beschreibt, solange die Schleife weiterlaufen soll.

Beispiel:

while ($i -lt 5)

Bedeutung:

Wiederholen, solange $i kleiner als 5 ist.

while

while prüft vor jedem Durchlauf.

$i = 0

while ($i -lt 3) {
    Write-Host $i
    $i++
}

Ausgabe:

0
1
2

Warum keine 3?

3 -lt 3 = falsch

do while

do while läuft mindestens einmal und prüft danach.

$x = 10

do {
    Write-Host $x
}
while ($x -lt 5)

Ausgabe:

10

Die Schleife läuft nur 1-mal, weil danach geprüft wird:

10 -lt 5 = falsch

do until

do until läuft mindestens einmal und stoppt, sobald die Bedingung wahr ist.

$punkte = 0

do {
    $punkte += 10
}
until ($punkte -ge 100)

Bedeutung:

Wiederholen, bis $punkte mindestens 100 ist.

for

for ist eine typische Zählschleife.

Aufbau:

for (Startwert; Bedingung; Veränderung) {
}

Beispiel:

for ($i = 0; $i -lt 3; $i++) {
    Write-Host $i
}

Ausgabe:

0
1
2

Ablauf:

Leerer Schleifenkörper

Auch wenn der Schleifenkörper leer ist, läuft die Schleife trotzdem.

for ($i = 0; $i -lt 3; $i++) {
}

Diese Schleife läuft 3-mal.

Sie gibt nur nichts aus.

foreach

foreach wird verwendet, um jedes Element einer Liste zu verarbeiten.

foreach ($datei in $dateien) {
    Write-Host $datei
}

Bedeutung:

Für jede Datei in $dateien wird der Code einmal ausgeführt.

Wenn die Liste leer ist, läuft foreach 0-mal.

Vergleichsoperatoren in PowerShell

Beispiele:

$i -lt 5    # kleiner als 5
$i -le 5    # kleiner oder gleich 5
$i -gt 5    # größer als 5
$i -ge 5    # größer oder gleich 5
$i -eq 5    # genau 5
$i -ne 5    # nicht 5

Wichtig: -lt und -le

-lt 5 = kleiner als 5

Läuft bei:

0, 1, 2, 3, 4

Nicht bei:

5

-le 5 = kleiner oder gleich 5

Läuft bei:

0, 1, 2, 3, 4, 5

while vs until

Beispiel mit while:

do {
    $punkte += 10
}
while ($punkte -lt 100)

Bedeutung:

Wiederholen, solange $punkte kleiner als 100 ist.

Beispiel mit until:

do {
    $punkte += 10
}
until ($punkte -ge 100)

Bedeutung:

Wiederholen, bis $punkte mindestens 100 ist.

Bei 100 abbrechen

Wenn bei 100 Schluss sein soll, ist bei do until logisch:

until ($punkte -ge 100)

Oder bei do while:

while ($punkte -lt 100)

Nicht passend wäre:

while ($punkte -le 100)

Denn bei 100 ist diese Bedingung noch wahr und die Schleife läuft nochmal.

Zähler erhöhen

$i++

ist dasselbe wie:

$i += 1

Beide erhöhen den Wert um 1.

Zähler verringern

$i--

ist dasselbe wie:

$i -= 1

Beide verringern den Wert um 1.

Größere Schritte

$i += 5

erhöht um 5.

$i -= 5

verringert um 5.

Initialisierung

Initialisierung bedeutet: Startwert setzen.

Beispiel:

$i = 0

Inkrement

Inkrement bedeutet: Wert erhöhen.

Beispiel:

$i++

oder:

$i += 1

Dekrement

Dekrement bedeutet: Wert verringern.

Beispiel:

$i--

oder:

$i -= 1

Endlosschleife

Eine Endlosschleife endet nicht von selbst.

Beispiel:

while ($true) {
    Write-Host "läuft"
}

Oder:

$x = 1

do {
    Write-Host $x
}
while ($x -lt 5)

Wenn $x nie verändert wird, bleibt die Bedingung immer wahr.

break

break beendet eine Schleife sofort.

while ($true) {
    break
}

continue

continue überspringt den Rest des aktuellen Durchlaufs und springt direkt zum nächsten Durchlauf.

for ($i = 1; $i -le 5; $i++) {
    if ($i -eq 3) {
        continue
    }

    Write-Host $i
}

Ausgabe:

1
2
4
5

Off-by-one-Fehler

Ein Off-by-one-Fehler passiert, wenn eine Schleife einmal zu viel oder einmal zu wenig läuft.

Typischer Unterschied:

$i -lt 5

läuft bis 4.

$i -le 5

läuft bis 5.

Merksätze

while = solange

until = bis

for = Zählschleife

foreach = für jedes Element

do while = mindestens einmal, dann solange

do until = mindestens einmal, dann bis

break = sofort raus

continue = nächster Durchlauf

-lt = kleiner als

-le = kleiner oder gleich

-gt = größer als

-ge = größer oder gleich

-eq = gleich

-ne = ungleich

PowerShell Schleifen – Zusatz

Grundsätzliche Schreibweise

PowerShell orientiert sich bei Schleifen an C-ähnlichen Sprachen.

Die Schleifenbedingung steht meistens in runden Klammern.

while ($x -lt 5)

Der Schleifenkörper steht in geschweiften Klammern.

{
    Write-Host $x
}

PowerShell-Befehlswörter sind nicht case-sensitive.

Das ist also gleichbedeutend:

for
For
FOR

Abweisende Schleifen

Abweisende Schleifen prüfen die Schleifenbedingung vor dem ersten Durchlauf.

Wenn die Bedingung direkt am Anfang falsch ist, wird der Schleifenkörper kein einziges Mal ausgeführt.

Beispiele:

while ($x -lt 5) {
}

for ($i = 1; $i -le 10; $i++) {
}

Nicht-abweisende Schleifen

Nicht-abweisende Schleifen prüfen die Schleifenbedingung am Ende des Schleifenkörpers.

Der Schleifenkörper wird deshalb mindestens einmal ausgeführt.

Beispiele:

do {
    Write-Host $x
}
while ($x -lt 5)

do {
    Write-Host $x
}
until ($x -ge 5)

for-Schleife

Die for-Schleife eignet sich, wenn man eine Laufvariable direkt in der Schleifenanweisung initialisieren und inkrementieren möchte.

Aufbau:

for (Initialisierung; Schleifenbedingung; Inkrementierung) {
    Anweisungen
}

Beispiel:

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

Bedeutung:

$i wird mit 1 initialisiert.
Die Schleife läuft, solange $i kleiner oder gleich 10 ist.
Nach jeder Iteration wird $i inkrementiert.

Laufvariable

Eine Laufvariable steuert, wie oft eine Schleife läuft.

Beispiel:

$i

In einer for-Schleife kann die Laufvariable direkt in der Schleifenanweisung gesetzt und verändert werden.

for ($i = 1; $i -le 10; $i++) {
}

Initialisieren

Initialisieren bedeutet: Eine Variable bekommt einen Startwert.

Beispiel:

$i = 1

Inkrementieren

Inkrementieren bedeutet: Eine Variable wird erhöht.

Beispiel:

$i++

Das ist gleichbedeutend mit:

$i += 1

while-Schleife

Die while-Schleife ist eine abweisende Schleife.

Sie prüft die Schleifenbedingung vor dem ersten Durchlauf.

Beispiel:

while ($i -le 10) {
    Write-Host $i
    $i++
}

Bei while besteht der Ausdruck nur aus einer Bedingung.

Wenn man eine Laufvariable verwenden möchte, muss man sie vorher initialisieren und im Schleifenkörper verändern.

Beispiel:

$i = 1

while ($i -le 10) {
    Write-Host $i
    $i++
}

while mit Eingabe und Zuweisung

In der Schleifenbedingung einer while-Schleife darf man auch Werte zuweisen oder Eingaben abfragen.

Beispiel:

while (($inp = Read-Host "Wählen Sie einen Befehl") -ne "Q") {
    Write-Host "Eingabe war $inp"
}

Bedeutung:

Read-Host fragt eine Eingabe ab.
Der Wert wird in $inp gespeichert.
Solange $inp nicht Q ist, läuft die Schleife weiter.

do-while

do-while ist eine nicht-abweisende Schleife.

Der Schleifenkörper läuft mindestens einmal.

Beispiel:

do {
    Write-Host $x
}
while ($x -lt 5)

Bedeutung:

Die Schleife läuft, solange die Bedingung wahr ist.
Sie bricht ab, wenn die Bedingung nicht mehr erfüllt ist.

do-until

do-until ist ebenfalls eine nicht-abweisende Schleife.

Der Schleifenkörper läuft mindestens einmal.

Beispiel:

do {
    Write-Host $x
}
until ($x -ge 5)

Bedeutung:

Die Schleife läuft, bis die Bedingung wahr wird.
Sie endet, wenn die Schleifenbedingung TRUE wird.

do-while und do-until gegenseitig ersetzen

do-while und do-until können sich grundsätzlich gegenseitig ersetzen, wenn man die Bedingung negiert.

Beispiel mit do-while:

do {
    $i++
}
while ($i -lt 5)

Gleiche Logik mit do-until:

do {
    $i++
}
until ($i -ge 5)

Merke:

do-while läuft, solange die Bedingung wahr ist.
do-until läuft, bis die Bedingung wahr wird.

break

break dient zur Schleifensteuerung.

break verlässt den aktuellen Block.

In Schleifen beendet break die Iteration und setzt den Programmablauf mit der nächsten Anweisung außerhalb des Schleifenkörpers fort.

Beispiel:

while ($true) {
    if ($fertig) {
        break
    }
}

Bedeutung:

Die Schleife läuft eigentlich dauerhaft.
Sobald $fertig wahr ist, beendet break die Schleife.

break in switch-Blöcken

break kann nicht nur in Schleifen verwendet werden, sondern auch innerhalb von switch-Blöcken.

Beispiel:

switch ($inp) {
    "L" { "Datei wird gelöscht"; break }
    "A" { "Datei wird angezeigt"; break }
    "R" { "Datei erhält Schreibschutz"; break }
    "Q" { "Ende"; break }
    default { "Ungültige Eingabe" }
}

Bedeutung:

break verlässt den switch-Block.

break bei verschachtelten Schleifen

Bei verschachtelten Schleifen verlässt break den aktuellen Schleifenblock.

Beispiel:

foreach ($a in 1..3) {
    foreach ($b in 1..3) {
        break
    }
}

Bedeutung:

break beendet hier die innere Schleife.
Die äußere Schleife kann weiterlaufen.

break mit Sprungmarke

PowerShell erlaubt break auch mit einer Sprungmarke.

Eine Sprungmarke beginnt mit einem Doppelpunkt.

Beispiel-Schema:

:MeineSchleife while ($true) {
    break MeineSchleife
}

Wichtig:

break mit Sprungmarke ist möglich.
Es sollte aber sparsam verwendet werden, weil es Code schwerer verständlich machen kann.

continue

continue dient ebenfalls zur Schleifensteuerung.

continue bricht die weitere Ausführung des aktuellen Schleifenkörpers ab.

Im Unterschied zu break verlässt continue die Schleife nicht komplett, sondern startet die nächste Iteration.

Beispiel:

foreach ($zahl in 1..5) {
    if ($zahl -eq 3) {
        continue
    }

    Write-Host $zahl
}

Ausgabe:

1
2
4
5

Bedeutung:

Bei 3 wird der restliche Schleifenkörper übersprungen.
Danach geht es mit der nächsten Iteration weiter.

Iteration

Eine Iteration ist ein einzelner Schleifendurchlauf.

Wenn eine Schleife 5-mal läuft, hat sie 5 Iterationen.

Implizite Iteration über Array-Elemente

PowerShell kann bei Arrays in bestimmten Fällen automatisch über die Elemente iterieren.

Beispiel:

($user).Surname

Wenn $user mehrere Objekte enthält, wird die Eigenschaft Surname für jedes Element ausgegeben.

Bedeutung:

Man braucht nicht immer eine explizite Schleife.
PowerShell kann Eigenschaften von Array-Elementen teilweise automatisch ausgeben.

foreach-Anweisung

Die foreach-Anweisung wird verwendet, um über Elemente eines Arrays oder einer Sammlung zu iterieren.

Beispiel:

$user = Get-ADUser -Filter *

foreach ($u in $user) {
    $u.Surname
}

Bedeutung:

$user enthält mehrere Objekte.
$u enthält immer das aktuelle Element des Arrays.
Der Schleifenkörper wird für jedes Element einmal ausgeführt.

ForEach-Object

ForEach-Object ist ein Cmdlet für die Verarbeitung von Pipeline-Objekten.

Beispiel:

Get-ADUser -Filter * | ForEach-Object {
    $_.Surname
}

Bedeutung:

Die Objekte kommen über die Pipeline.
ForEach-Object verarbeitet jedes Objekt einzeln.

foreach als Alias für ForEach-Object

Wichtig: foreach kann zwei Bedeutungen haben.

Als Schleifenanweisung:

foreach ($u in $user) {
    $u.Surname
}

Als Alias für ForEach-Object in der Pipeline:

Get-ADUser -Filter * | foreach {
    $_.Surname
}

Merke:

foreach (...) { }     = foreach-Anweisung
| foreach { }         = Alias für ForEach-Object

% als Alias für ForEach-Object

% ist ein weiterer Alias für ForEach-Object.

Diese Schreibweisen sind vergleichbar:

Get-ADUser -Filter * | ForEach-Object {
    $_.Surname
}

Get-ADUser -Filter * | foreach {
    $_.Surname
}

Get-ADUser -Filter * | % {
    $_.Surname
}

Merke:

% = Alias für ForEach-Object

$_

$_ ist eine automatische Variable.

Bei ForEach-Object steht $_ für das aktuelle Objekt aus der Pipeline.

Beispiel:

Get-ADUser -Filter * | ForEach-Object {
    $_.Surname
}

Bedeutung:

$_ = aktuelles Pipeline-Objekt

foreach-Anweisung vs. ForEach-Object

Die foreach-Anweisung arbeitet mit einer vorhandenen Sammlung.

foreach ($u in $user) {
    $u.Surname
}

ForEach-Object arbeitet typischerweise mit Pipeline-Ausgabe.

Get-ADUser -Filter * | ForEach-Object {
    $_.Surname
}

Merke:

foreach-Anweisung = gut für vorhandene Arrays oder Sammlungen
ForEach-Object    = gut für Pipeline-Verarbeitung

Performance: foreach-Anweisung und ForEach-Object

Bei vielen Schleifendurchläufen und komplexeren Berechnungen im Schleifenkörper ist die herkömmliche foreach-Schleife oft schneller.

Beispiel foreach-Anweisung:

$user = Get-ADUser -Filter *

foreach ($u in $user) {
    $u.Surname
}

Beispiel ForEach-Object:

Get-ADUser -Filter * | ForEach-Object {
    $_.Surname
}

Merke:

foreach-Anweisung = oft schneller bei vielen Durchläufen
ForEach-Object    = oft kürzer und praktisch in der Pipeline

Typische Auswahl der Schleife

Wichtige Merksätze

Schleifenbedingung = Bedingung, die den Ablauf der Schleife steuert.

Schleifenkörper = Anweisungen, die wiederholt ausgeführt werden.

Abweisende Schleifen können 0-mal laufen.

Nicht-abweisende Schleifen laufen mindestens 1-mal.

for-Schleife eignet sich besonders mit Laufvariable.

while-Schleife eignet sich, wenn nur eine Bedingung geprüft werden soll.

do-while läuft, solange die Bedingung wahr ist.

do-until läuft, bis die Bedingung wahr wird.

break verlässt den aktuellen Block.

continue startet die nächste Iteration.

foreach-Anweisung ist nicht dasselbe wie ForEach-Object.

foreach und % können Aliase für ForEach-Object sein.

$_ steht für das aktuelle Pipeline-Objekt.

PowerShell Trainer – Benannte Parameter und Parameter-Dekorator

PowerShell Trainer – Fragen und Antworten zu Parametern