PS C:\pollhammer> .\uebungszettel\03-funktionen.ps1

03 / Funktionen & Skripte

Auf diesem Zettel baust du eigene Funktionen mit Parametern, Default-Werten und return — und machst aus deinem Code echte .ps1-Skripte, die du mit eigenen Parametern startest.

9 Aufgaben function, param(), return & .ps1-Dateien ausführen Fortschritt wird gespeichert

▸ man 03-funktionen — das Wichtigste in Kürze

function Say-Hello { ... } definiert eine Funktion — aufgerufen wird sie einfach per Namen: Say-Hello (ohne Klammern!).
param($Name = "Stranger", $Age = 0) deklariert Parameter mit Default-Werten. Aufruf: Greet-Person -Name "Max" -Age 25.
Typisierte Parameter wie [int]$Number lehnen falsche Typen mit einem Fehler ab — dein Code wird robuster.
Achtung, Falle: JEDE Ausgabe in einer Funktion wird zurückgegeben, nicht nur return! Unterdrücken mit $null = ... oder | Out-Null.
Skripte startest du mit .\hello.ps1 (aktueller Ordner) oder & "C:\Pfad\hello.ps1" (voller Pfad).
Meldung 'running scripts is disabled'? Einmalig Set-ExecutionPolicy RemoteSigned -Scope CurrentUser ausführen.
Ein param(...)-Block ganz oben in der Datei macht das ganze Skript parametrisierbar: .\greet.ps1 -Name "Max".

~/uebungen/03-funktionen.ps1 : aufgabe_01✓ gelöstcode vervollständigen

01Deine erste Funktion

Mit welchem Schlüsselwort definierst du in PowerShell eine Funktion?

 Say-Hello {
    Write-Host "Hello, World!"
}

Say-Hello

Das Schlüsselwort function definiert eine Funktion. Danach folgen der Name (am besten im Verb-Nomen-Muster wie bei Cmdlets) und der Code in { }. Aufgerufen wird sie einfach per Namen — Say-Hello — ganz ohne Klammern.

~/uebungen/03-funktionen.ps1 : aufgabe_02✓ gelöstoutput vorhersagen

02Default-Wert in Aktion

function Greet-Person {
    param($Name = "Stranger")
    Write-Host "Hello, $Name!"
}

Greet-Person

Was gibt der Aufruf Greet-Person (ohne Parameter) aus?

Wird beim Aufruf kein -Name übergeben, greift der Default-Wert "Stranger" aus dem param()-Block. Weil der String in doppelten Anführungszeichen steht, wird $Name interpoliert — es erscheint Hello, Stranger!.

~/uebungen/03-funktionen.ps1 : aufgabe_03✓ gelöst1 aus N

03Skript starten

Du hast hello.ps1 gespeichert und bist mit Set-Location schon im richtigen Ordner. Wie startest du das Skript?

hello.ps1 — einfach den Dateinamen eintippen .\hello.ps1 — mit .\ für das aktuelle Verzeichnis run hello.ps1 Start-Script hello.ps1

Aus Sicherheitsgründen führt PowerShell Skripte im aktuellen Ordner nur mit explizitem Pfad-Präfix aus: .\hello.ps1. Der bloße Dateiname reicht nicht — so kann kein Skript versehentlich einen echten Befehl 'überschatten'. Alternativ geht der volle Pfad: & "C:\Scripts\hello.ps1". Ein Cmdlet Start-Script gibt es nicht.

~/uebungen/03-funktionen.ps1 : aufgabe_04✓ gelöstcode vervollständigen

04Typisierte Parameter

Ergänze die Typangabe, damit $A — genau wie $B — nur ganze Zahlen akzeptiert.

function Add-Numbers {
    param($A, [int]$B)
    return $A + $B
}

Add-Numbers -A 3 -B 4

Mit [int] vor dem Variablennamen erzwingst du den Datentyp. Der Aufruf Add-Numbers -A "abc" -B 4 schlägt dann sofort mit einer klaren Fehlermeldung fehl, statt irgendwo später falsche Ergebnisse zu liefern. [int] ist die Kurzform von [System.Int32].

~/uebungen/03-funktionen.ps1 : aufgabe_05✓ gelöstoutput vorhersagen

05Die Rückgabe-Falle

function Get-Double {
    param([int]$Number)
    Write-Output "Working..."
    return $Number * 2
}

$result = Get-Double -Number 21
Write-Host $result.Count

Was gibt die letzte Zeile aus?

Die große Falle bei Funktionen: JEDE nicht unterdrückte Ausgabe wird zurückgegeben, nicht nur return! $result ist deshalb ein Array mit zwei Elementen — "Working..." und 42 — also ist $result.Count gleich 2. Willst du nur 42, unterdrücke die Zwischenausgabe mit $null = ... oder | Out-Null (oder nutze Write-Host, das schreibt nur auf die Konsole).

~/uebungen/03-funktionen.ps1 : aufgabe_06✓ gelöstmehrfachauswahl

06Was gibt eine Funktion zurück?

Welche Aussagen über Rückgabewerte von PowerShell-Funktionen stimmen? Kreuze zwei an.

Jede nicht unterdrückte Ausgabe in der Funktion landet im Rückgabewert — nicht nur der Wert hinter return. Nur der Wert hinter return wird zurückgegeben, alle anderen Ausgaben werden automatisch verworfen. Mit | Out-Null oder $null = ... unterdrückst du unerwünschte Ausgaben, damit sie nicht im Rückgabewert landen. return kann in PowerShell keine Werte zurückgeben, es beendet nur die Funktion. Eine Funktion muss immer genau ein return enthalten, sonst gibt es einen Fehler.

In PowerShell wandert alles, was eine Funktion ausgibt, in den Rückgabewert — return gibt seinen Wert zurück UND beendet die Funktion, ist aber nicht der einzige Weg. Unerwünschte Ausgaben (z. B. von Cmdlets, die etwas zurückliefern) unterdrückst du mit | Out-Null oder $null = .... Ein return ist optional — eine Funktion ganz ohne return ist völlig legal.

~/uebungen/03-funktionen.ps1 : aufgabe_07✓ gelöstzuordnung

07Bausteine zuordnen

Ordne jedem Code-Baustein seine Bedeutung zu.

`param($Name = "Stranger")`→

`[int]$Number`→

`| Out-Null`→

`& "C:\Scripts\hello.ps1"`→

param($Name = "Stranger") setzt einen Default, der greift, wenn der Aufrufer nichts übergibt. [int]$Number erzwingt den Typ. | Out-Null schluckt die Ausgabe — wichtig gegen die Rückgabe-Falle. Und & (der Call-Operator) führt ein Skript an einem beliebigen Pfad aus, ohne dass du erst per Set-Location hinwechseln musst.

~/uebungen/03-funktionen.ps1 : aufgabe_08✓ gelöstcode vervollständigen

08Skripte erlauben

Dein Skript startet nicht ('running scripts is disabled on this system'). Welche Policy erlaubt lokale Skripte, verlangt aber Signaturen für heruntergeladene?

Set-ExecutionPolicy  -Scope CurrentUser

RemoteSigned ist der übliche Kompromiss: Selbst geschriebene, lokale Skripte laufen ohne Weiteres, aber aus dem Internet heruntergeladene brauchen eine digitale Signatur. Mit -Scope CurrentUser gilt die Einstellung nur für dich — dafür brauchst du keine Admin-Rechte.

~/uebungen/03-funktionen.ps1 : aufgabe_09✓ gelösthands-on

09greet.ps1 — dein Skript mit Parametern

Öffne eine echte PowerShell und arbeite die Schritte durch:

Erstelle eine Datei greet.ps1. Ganz oben kommt ein Skript-Parameter hin: param([string]$Name = "World").
Definiere darunter eine Funktion Get-Greeting mit einem Parameter [string]$Person, die den Text Hello, <Person>! per return zurückgibt.
Rufe die Funktion am Ende des Skripts mit $Name auf und gib das Ergebnis mit Write-Host aus.
Wechsle mit Set-Location in den Ordner und starte zweimal: .\greet.ps1 und .\greet.ps1 -Name "Max". Kommt eine ExecutionPolicy-Fehlermeldung, führe vorher Set-ExecutionPolicy RemoteSigned -Scope CurrentUser aus.

erledigt — hab ich gemacht

# greet.ps1
param([string]$Name = "World")

function Get-Greeting {
    param([string]$Person)
    return "Hello, $Person!"
}

$message = Get-Greeting -Person $Name
Write-Host $message

# Ausfuehren (in der PowerShell-Konsole):
#   Set-Location C:\Scripts
#   .\greet.ps1               # -> Hello, World!
#   .\greet.ps1 -Name "Max"   # -> Hello, Max!

Der param()-Block ganz oben macht das Skript selbst parametrisierbar — genau wie bei einer Funktion, nur auf Datei-Ebene. Ohne -Name greift der Default "World". Die Funktion kapselt die Logik, return liefert den fertigen String zurück, und Write-Host zeigt ihn an. Das .\-Präfix ist Pflicht, wenn das Skript im aktuellen Ordner liegt.

← 02 · Kontrollfluss 04 · Dateien & Ordner →