Funktionen und Parameter

Core

Lernziele

• Funktionen mit Parametern und Validierung schreiben
• Ausgabe (Rückgabe) sauber gestalten

Funktionen sind ein wesentlicher Bestandteil von PowerShell, da sie es dir ermöglichen, wiederverwendbaren und modularen Code zu schreiben. Eine Funktion wird mit dem Schlüsselwort function definiert, gefolgt von einem Funktionsnamen und einem Codeblock. Parameterblöcke, die mit param() definiert werden, erlauben es dir, Eingabeparameter zu spezifizieren, deren Datentypen festzulegen und zusätzliche Attribute wie Pflichtparameter oder Validierung zu nutzen.

1. Grundlagen von Funktionen

1.1 Einfache Funktion ohne Parameter

Eine Funktion ohne Parameter ist sehr einfach aufgebaut:

function Show-Hello {
    "Hello, World!"
}

Aufruf:

Show-Hello

1.2 Funktion mit einem Parameterblock

Durch den Einsatz eines Parameterblocks kannst du deiner Funktion Eingaben übergeben:

function Get-Greeting {
    param(
        [Parameter(Mandatory = $true)]
        [string]$Name,

        [int]$Age = 0  # Optionaler Parameter mit Standardwert 0
    )
    "Hello, $Name! You are $Age years old."
}

Aufruf:

Get-Greeting -Name "Max" -Age 30

2. Erweiterte Parameterblöcke und Validierung

Du kannst Parameter zusätzlich validieren und deren Werte einschränken. Dies erhöht die Zuverlässigkeit deiner Funktionen.

2.1 Beispiel mit Validierung und Switch-Parameter

function Set-Configuration {
    param(
        [Parameter(Mandatory = $true)]
        [ValidateSet("Low", "Medium", "High")]
        [string]$Priority,

        [switch]$VerboseOutput
    )
    if ($VerboseOutput) {
        Write-Output "Setting configuration with high verbosity."
    }
    else {
        Write-Output "Setting configuration with priority: $Priority."
    }
}

Aufruf:

Set-Configuration -Priority "High" -VerboseOutput

2.2 Parameter als Objekte

Manchmal ist es hilfreich, komplexe Parameter als Objekte zu übergeben, um strukturierte Daten zu verarbeiten:

function Show-UserData {
    param(
        [Parameter(Mandatory = $true)]
        [PSCustomObject]$UserInfo
    )
    "User Name: $($UserInfo.Name)"
    "User Age: $($UserInfo.Age)"
}

Aufruf:

$user = [PSCustomObject]@{
    Name = "Alice"
    Age  = 28
}
Show-UserData -UserInfo $user

3. Rückgabe: Alles, was nicht zugewiesen wird, ist Ausgabe

In PowerShell gibt eine Funktion alles zurück, was in ihr ausgegeben wird, nicht nur den Wert hinter return.

function Get-Summe {
    param([int]$A, [int]$B)
    $A + $B            # reicht: der Wert wird ausgegeben
}
$x = Get-Summe -A 2 -B 3

Unbeabsichtigte Ausgaben (zum Beispiel von New-Item oder .Add()) landen mit im Ergebnis. Unterdrücke sie mit | Out-Null oder $null = …. Für Hinweise an den Menschen nutzt du Write-Verbose, Write-Warning oder Write-Host, nicht Write-Output.

Verben

Funktionen heißen wie Cmdlets Verb-Substantiv. Verwende genehmigte Verben (Get-Verb). Say-Hello und Process-Data sind nicht genehmigt, Show-Hello, Convert-Data sind es.

4. Best Practices für Funktionen

• Modularität:
  Teile komplexe Aufgaben in mehrere kleine Funktionen auf, die jeweils eine spezifische Aufgabe erledigen.

• Parameterüberprüfung:
  Nutze Parameterattribute wie [Parameter(Mandatory = $true)] und Validierungsattribute wie [ValidateSet()] oder [ValidateRange()], um sicherzustellen, dass deine Funktion korrekte Eingaben erhält.

• Dokumentation:
  Kommentiere deine Funktionen mit Hilfe von Kommentarblöcken (Help Comments), um den Zweck, Parameter und Beispiele für den Aufruf zu dokumentieren.

• Fehlerbehandlung:
  Integriere Try/Catch-Blöcke innerhalb deiner Funktionen, um Fehler abzufangen und sinnvolle Fehlermeldungen auszugeben.

5. Zusammenfassung

• Definition:
  Funktionen werden in PowerShell mit dem function-Schlüsselwort definiert und ermöglichen es dir, Code in wiederverwendbare Blöcke zu unterteilen.

• Parameterblöcke:
  Der Einsatz von param() erlaubt es dir, Eingabewerte zu definieren, Datentypen festzulegen und die Validierung der Parameter zu erzwingen.

• Best Practices:
  Durch Modularität, klare Namensgebung, umfangreiche Dokumentation und Fehlerbehandlung wird dein Code robuster und leichter wartbar.

Diese Techniken helfen dir, deine PowerShell-Skripte strukturiert und effizient aufzubauen und die Wiederverwendbarkeit sowie Wartbarkeit deines Codes zu verbessern.