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:
$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
$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:
$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:
'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:
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:
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:
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):
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:
$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:
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:
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).
- Welche Dateien sind größer als 400 Bytes? Zeigen Sie
NameundLength, größte zuerst. - Wie viele Dateien gibt es je Endung, und wie viele Bytes insgesamt je Endung?
- Wie ruft man die Größe in Kilobyte mit einer Nachkommastelle in einer eigenen Spalte
KBab?
Lösung 1
Get-ChildItem $root | Where-Object Length -gt 400 | Sort-Object Length -Descending | Select-Object Name, Length. Ergebnis:bericht-west.txt(900) undbericht-sued.txt(480).Get-ChildItem $root | Group-Object Extension | ForEach-Object { [pscustomobject]@{ Endung = $_.Name; Anzahl = $_.Count; Bytes = ($_.Group | Measure-Object Length -Sum).Sum } }. Jede Gruppe hat die EigenschaftGroupmit den Objekten;[pscustomobject]@{…}erzeugt ein neues Objekt (Lektion PS.2.1).Select-Object Name, @{ n = 'KB'; e = { [math]::Round($_.Length / 1KB, 1) } }.
Übung 2: Das Format-Problem erleben
- Führen Sie
$x = Get-ChildItem $root | Format-Table Nameaus und lesen Sie$x[0].GetType().FullName. Was stellen Sie fest? - Schreiben Sie eine Funktion
Get-GrosseDateien, die Dateien über 400 Bytes zurückgibt, einmal mitFormat-Tableam Ende, einmal ohne. Wie unterscheiden sich(Get-GrosseDateien).Countund(Get-GrosseDateien | Select-Object -First 1).Name? - Wo gehört
Format-Tablehin?
Lösung 2
- Das erste Objekt ist ein
FormatStartData, keine Datei. - Ohne
Format-Tableist.Count2 und.Namebericht-sued.txt; mitFormat-Tableist.Count6 (gezählt werden Formatobjekte, keine Dateien) und.Nameleer, denn die Funktion gibt Formatobjekte zurück. - In die oberste Ebene Ihres Aufrufs, ganz am Ende, nur für die Anzeige.
Übung 3: -First und die Ströme
- Schreiben Sie eine Pipeline
1..5 | ForEach-Object { Write-Host "erzeugt $_"; $_ } | Select-Object -First 2und beschreiben Sie, was passiert. - Welche Daten bleiben in
$r, wenn die FunktionTaus 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
- „erzeugt 1“, 1, „erzeugt 2“, 2; der Rest läuft nicht mehr.
$renthält nurdaten. 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 -Firstden 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.