In vielen Shells ist die Ausgabe eines Befehls Text, und der nächste Befehl muss diesen Text mit grep, awk oder cut wieder zerlegen. PowerShell geht anders vor: Ein Befehl gibt Objekte zurück, und die Pipeline reicht diese Objekte unverändert an den nächsten weiter. Das spart das Zerlegen und macht Skripte robust, weil eine Spalte nicht mehr „das dritte Wort in der Zeile“ ist, sondern eine benannte Eigenschaft. Diese Lektion zeigt das an einem kleinen Übungsverzeichnis.

Das Übungsverzeichnis

Alle Beispiele dieser Lektion laufen in einem Ordner, den ein Skript neu anlegt. Er liegt im temporären Verzeichnis, enthält fünf Dateien verschiedener Größe und trägt die Namen einer erfundenen Firma, der Nordlicht Reisen GmbH:

PowerShell
$root = Join-Path ([IO.Path]::GetTempPath()) 'nordlicht-uebung'
if (Test-Path -LiteralPath $root) { [IO.Directory]::Delete($root, $true) }
New-Item -ItemType Directory $root | Out-Null
$files = [ordered]@{ 'bericht-nord.txt'=120; 'bericht-sued.txt'=480; 'preise.csv'=300; 'notizen.md'=50; 'bericht-west.txt'=900 }
foreach ($n in $files.Keys) { Set-Content (Join-Path $root $n) ('x' * $files[$n]) -NoNewline }

Die Zahl hinter jedem Namen ist die Größe der Datei in Bytes. -NoNewline verhindert, dass Set-Content einen Zeilenumbruch anhängt, damit die Größe stimmt. Das Aufräumen am Ende ([IO.Directory]::Delete($root, $true)) steht in jeder Übung, die den Ordner anlegt; es löscht nur diesen einen, selbst angelegten Ordner.

Alles ist ein Objekt

PowerShell
$f = Get-ChildItem $root
$f.GetType().FullName
$f[0].GetType().FullName
System.Object[]
System.IO.FileInfo

Get-ChildItem hat fünf Objekte zurückgegeben, in einem Array (System.Object[]), und jedes Element ist eine System.IO.FileInfo: ein .NET-Typ, der alles weiß, was das Dateisystem über eine Datei sagt. Eigenschaften sind Werte des Objekts (Name, Length, LastWriteTime), Methoden sind Dinge, die es kann (Delete(), CopyTo(…)). Was ein Objekt hat, verrät Get-Member:

PowerShell
$f | Get-Member -MemberType Property | Select-Object -First 4 Name, TypeName | Format-Table -AutoSize
Name            TypeName
----            --------
Attributes      System.IO.FileInfo
CreationTime    System.IO.FileInfo
CreationTimeUtc System.IO.FileInfo
Directory       System.IO.FileInfo

Die Spalte TypeName nennt den Typ, zu dem die Eigenschaften gehören (hier immer FileInfo). Der Befehl zeigt die ersten vier von vielen. Get-Member ist Ihr Werkzeug Nummer eins, wenn Sie nicht wissen, was ein Befehl liefert: Hängen Sie | Get-Member an und lesen Sie. Dasselbe gilt für Methoden und Eigenschaften von Zeichenketten und Daten:

PowerShell
'nordlicht'.ToUpper()
'nordlicht'.Length
(Get-Date '2025-03-01').AddDays(10).ToString('yyyy-MM-dd')
NORDLICHT
9
2025-03-11

Die Pipeline

Der senkrechte Strich | verbindet Befehle: Alles, was der linke Befehl ausgibt, geht Objekt für Objekt an den rechten. Fünf Cmdlets decken den Alltag ab.

Where-Object filtert. Behalten werden die Objekte, für die die Bedingung gilt:

PowerShell
Get-ChildItem $root | Where-Object Length -gt 200 | Sort-Object Length -Descending | Select-Object Name, Length
Name             Length
----             ------
bericht-west.txt    900
bericht-sued.txt    480
preise.csv          300

Die Kurzform Where-Object Length -gt 200 (Eigenschaft, Operator, Wert) genügt für einfache Bedingungen; für zusammengesetzte nehmen Sie einen Skriptblock mit $_ als dem aktuellen Objekt: Where-Object { $_.Length -gt 200 -and $_.Extension -eq '.txt' }. Die Vergleichsoperatoren (-gt, -eq, -like) lernen Sie in Lektion PS.2.1 genauer.

Sort-Object sortiert, Select-Object wählt Eigenschaften aus (oder die ersten und letzten Objekte, siehe unten). Group-Object gruppiert und Measure-Object rechnet:

PowerShell
Get-ChildItem $root | Group-Object Extension | Select-Object Name, Count | Sort-Object Name
(Get-ChildItem $root | Measure-Object Length -Sum -Average).Sum
Name Count
---- -----
.csv     1
.md      1
.txt     3

1850

Measure-Object liefert ein Objekt mit Count, Sum, Average, Minimum und Maximum; hier haben wir nur die Summe herausgenommen.

ForEach-Object führt für jedes Objekt Code aus, mit $_ als dem Objekt:

PowerShell
Get-ChildItem $root | ForEach-Object { '{0} hat {1} Bytes' -f $_.Name, $_.Length }

Das Format '{0} hat {1} Bytes' -f … füllt Platzhalter. Kennen Sie ein Cmdlet für die Aufgabe, bevorzugen Sie es vor ForEach-Object: Es ist kürzer und lesbarer.

Berechnete Eigenschaften

Manchmal fehlt die Spalte, die Sie brauchen: Die Größe soll in Kilobyte stehen, und die Spalte soll KB heißen. Select-Object nimmt dafür eine Hashtable mit Name (n) und Expression (e):

PowerShell
Get-ChildItem $root |
    Select-Object Name, @{ n = 'KB'; e = { [math]::Round($_.Length / 1KB, 2) } } |
    Sort-Object Name
Name               KB
----               --
bericht-nord.txt 0,12
bericht-sued.txt 0,47
bericht-west.txt 0,88
notizen.md       0,05
preise.csv       0,29

Das Dezimalkomma stammt von der Spracheinstellung dieses Rechners (Deutsch); bei Ihnen steht dort vielleicht ein Punkt. 1KB ist eine Kurzschreibweise für 1024. Das Ergebnis ist wieder eine Liste von Objekten, nur mit der neuen Eigenschaft: Sie können weiter filtern, sortieren und summieren.

Format-Befehle sind nur für die Augen

Format-Table, Format-List und Format-Wide bereiten Ausgabe für den Bildschirm auf. Sie machen aus Objekten keine besseren Objekte, sondern Formatanweisungen. Daraus folgt eine Regel mit einer Falle:

PowerShell
$x = Get-ChildItem $root | Format-Table Name
$x[0].GetType().FullName
Microsoft.PowerShell.Commands.Internal.Format.FormatStartData

$x enthält jetzt keine Dateien mehr, sondern Formatobjekte (FormatStartData und weitere), mit denen kein Befehl danach etwas anfangen kann. Deshalb steht ein Format-* immer ganz am Ende der Pipeline, und nie in einer Funktion, die Daten zurückgeben soll. Wer Daten braucht, nimmt Select-Object; wer sie auf dem Bildschirm schön haben will, formatiert ganz zuletzt. (Für den Kurstext haben wir dem Format-Befehl ein Out-String oder ein Format-List angehängt, damit das Beispiel im Skript als Text erscheint.)

Select-Object -First und seine Folge

Select-Object -First 2 nimmt die ersten beiden Objekte und beendet dann die Pipeline. Das ist praktisch bei langen Listen, hat aber eine Wirkung auf den Befehl davor:

PowerShell
1..5 | ForEach-Object { Write-Host "erzeugt $_"; $_ } | Select-Object -First 2
erzeugt 1
1
erzeugt 2
2

Der Befehl davor wird nach dem zweiten Objekt abgebrochen: „erzeugt 3“ erscheint nie. Bei einer harmlosen Schleife ist das gut. Bei einem Befehl, der etwas ändert oder dessen Exit-Code Sie noch brauchen (ein externes Programm, siehe Lektion PS.2.3), ist es eine Falle: Sie sehen nur einen Teil, und $LASTEXITCODE gehört zu dem Befehl, der davor lief. Merken Sie sich: -First nur auf Befehlen, die nichts ändern und deren Ende Sie nicht brauchen.

Ausgabe und Streams

PowerShell hat mehrere Ausgabeströme: Erfolg (Stream 1, die Daten), Fehler (2), Warnung (3), Verbose (4), Debug (5) und Information (6). Nur der Erfolgsstrom läuft durch die Pipeline. Meldungen für Menschen gehören in die anderen:

PowerShell
function T { Write-Output 'daten'; Write-Warning 'warn'; Write-Verbose 'v' -Verbose; Write-Information 'info' -InformationAction Continue }
$r = T 3>$null 4>$null 6>$null
$r
daten

3>$null leitet den Warnungsstrom ins Nichts, 4> den Verbose-Strom, 6> den Informationsstrom. Übrig bleibt, was durch die Pipeline gehört: daten. Wer in einer Funktion mit Write-Host Daten ausgibt, nimmt dem Aufrufer diese Daten, denn Write-Host ist kein Teil der Pipeline. Daten gehören nach Write-Output (oder einfach als Wert in die Zeile), Meldungen nach Write-Verbose, Write-Warning oder Write-Information. In Lektion PS.2.2 sehen Sie, wie eine Funktion das umsetzt.

Ausgabe in Dateien

Out-File (oder die Umleitung >) schreibt die formatierte Ausgabe in eine Datei, also das, was Sie am Bildschirm sähen. Für Daten, die ein anderes Programm einlesen soll, nehmen Sie besser Export-Csv oder ConvertTo-Json (Lektion PS.1.3), weil sie die Objekte verlustfrei schreiben.

Übung 1: Die Pipeline lesen

Legen Sie das Übungsverzeichnis an (Skript oben).

  1. Welche Dateien sind größer als 400 Bytes? Zeigen Sie Name und Length, größte zuerst.
  2. Wie viele Dateien gibt es je Endung, und wie viele Bytes insgesamt je Endung?
  3. Wie ruft man die Größe in Kilobyte mit einer Nachkommastelle in einer eigenen Spalte KB ab?

Lösung 1

  1. Get-ChildItem $root | Where-Object Length -gt 400 | Sort-Object Length -Descending | Select-Object Name, Length. Ergebnis: bericht-west.txt (900) und bericht-sued.txt (480).
  2. Get-ChildItem $root | Group-Object Extension | ForEach-Object { [pscustomobject]@{ Endung = $_.Name; Anzahl = $_.Count; Bytes = ($_.Group | Measure-Object Length -Sum).Sum } }. Jede Gruppe hat die Eigenschaft Group mit den Objekten; [pscustomobject]@{…} erzeugt ein neues Objekt (Lektion PS.2.1).
  3. Select-Object Name, @{ n = 'KB'; e = { [math]::Round($_.Length / 1KB, 1) } }.

Übung 2: Das Format-Problem erleben

  1. Führen Sie $x = Get-ChildItem $root | Format-Table Name aus und lesen Sie $x[0].GetType().FullName. Was stellen Sie fest?
  2. Schreiben Sie eine Funktion Get-GrosseDateien, die Dateien über 400 Bytes zurückgibt, einmal mit Format-Table am Ende, einmal ohne. Wie unterscheiden sich (Get-GrosseDateien).Count und (Get-GrosseDateien | Select-Object -First 1).Name?
  3. Wo gehört Format-Table hin?

Lösung 2

  1. Das erste Objekt ist ein FormatStartData, keine Datei.
  2. Ohne Format-Table ist .Count 2 und .Name bericht-sued.txt; mit Format-Table ist .Count 6 (gezählt werden Formatobjekte, keine Dateien) und .Name leer, denn die Funktion gibt Formatobjekte zurück.
  3. In die oberste Ebene Ihres Aufrufs, ganz am Ende, nur für die Anzeige.

Übung 3: -First und die Ströme

  1. Schreiben Sie eine Pipeline 1..5 | ForEach-Object { Write-Host "erzeugt $_"; $_ } | Select-Object -First 2 und beschreiben Sie, was passiert.
  2. Welche Daten bleiben in $r, wenn die Funktion T aus dem Abschnitt „Ausgabe und Streams“ ohne die Umleitungen aufgerufen wird: $r = T? Probieren Sie es aus und erklären Sie, wohin Warnung, Verbose-Zeile und Information gehen.

Lösung 3

  1. „erzeugt 1“, 1, „erzeugt 2“, 2; der Rest läuft nicht mehr.
  2. $r enthält nur daten. Warnung, Verbose-Zeile und Information erscheinen auf dem Bildschirm (bei der Warnung steht je nach Sprache „WARNUNG: warn“ oder „WARNING: warn“ davor), aber sie gehören nicht zum Rückgabewert.

(Danach: [IO.Directory]::Delete($root, $true) räumt das Übungsverzeichnis auf.)

Was Sie jetzt können

  • Sie erklären, dass PowerShell Objekte weitergibt, und lesen mit Get-Member, was ein Objekt kann.
  • Sie filtern, sortieren, gruppieren, zählen und summieren mit Where-Object, Sort-Object, Group-Object, Measure-Object, Select-Object.
  • Sie bilden berechnete Eigenschaften.
  • Sie setzen Format-* ans Ende und geben aus Funktionen nur Objekte zurück.
  • Sie wissen, dass Select-Object -First den Befehl davor abbricht.
  • Sie unterscheiden Daten (Erfolgsstrom) von Meldungen (Warnung, Verbose, Information).

Die nächste Lektion geht zu den Dingen, auf die diese Objekte zeigen: Dateien, Umgebungsvariablen und strukturierte Daten.

Weiterlesen