Skip to main content

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:

Teil Erklärung
param() Bereich, in dem Parameter definiert werden
[string] Datentyp des Parameters
$Name Name des Parameters als Variable

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:

Teil Erklärung
.\person.ps1 Skript wird gestartet
-Name Parametername
"Felix" Wert für den Parameter Name
-Alter Parametername
30 Wert für den Parameter Alter

Datentypen bei Parametern

Man kann festlegen, welchen Datentyp ein Parameter erwartet.

Beispiele:

Datentyp Bedeutung Beispiel
[string] Text "Felix"
[int] Ganze Zahl 30
[bool] Wahr/Falsch $true
[string[]] Mehrere Texte "PC1","PC2"
[switch] Schalterparameter -VerboseMode

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:

Eigenschaft Bedeutung
Mandatory Parameter ist verpflichtend
Position Parameter kann über seine Position erkannt werden
ValueFromPipeline Wert kann aus der Pipeline kommen
ValueFromPipelineByPropertyName Wert kann über passenden Eigenschaftsnamen aus der Pipeline kommen
HelpMessage Hilfetext für den Parameter

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:

Position Wert Parameter
0 "Felix" Name
1 30 Alter

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.

Art Beispiel Erklärung
Named Parameter .\test.ps1 -Name "Felix" Parametername wird angegeben
Positional Parameter .\test.ps1 "Felix" PowerShell erkennt den Parameter über die Position

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:

Vorteil Erklärung
Wiederverwendbar Skript funktioniert mit verschiedenen Werten
Flexibler Werte werden beim Start übergeben
Wartbarer Skript muss nicht ständig geändert werden
Sicherer Werte können validiert werden
Professioneller Entspricht eher echter Administration

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:

Punkt Bedeutung
param() Definiert eigene Parameter
[string], [int], [switch] Legt Datentypen fest
Mandatory Macht Parameter verpflichtend
Position Erlaubt positionelle Übergabe
ValidateSet Beschränkt erlaubte Werte
ValidateNotNullOrEmpty Verhindert leere Werte
[switch] Erstellt Schalterparameter
$args Enthält unbenannte Argumente
CmdletBinding Macht Funktionen cmdletähnlicher

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:

Teil Bedeutung
param() Definiert Eingabeparameter
[Parameter(Mandatory)] Parameter ist verpflichtend
[string] Erwartet Text
$ComputerName Variable für den übergebenen Wert
Test-Connection Prüft Netzwerkverbindung
-ComputerName $ComputerName Nutzt den übergebenen Wert

Kurzer Merksatz

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

Back to top