Die Objekte aus der letzten Lektion kamen aus dem Dateisystem. Dieselben Befehle (Get-ChildItem, Get-Item, Get-Content) arbeiten aber auch mit ganz anderen Dingen: Umgebungsvariablen, der Registry unter Windows, den Funktionen der Sitzung. Möglich machen das Provider. In dieser Lektion lernen Sie sie kennen, lesen und schreiben Dateien richtig (Kodierung, Pfade) und verarbeiten die beiden Formate, mit denen Sie am häufigsten zu tun haben: CSV und JSON.

Provider und Laufwerke

Ein Provider macht einen Datenspeicher so zugänglich, als wäre er ein Laufwerk. Jedes Laufwerk hat einen Namen und gehört zu einem Provider:

PowerShell
Get-PSDrive -PSProvider FileSystem, Environment | Select-Object Name, @{ n = 'Provider'; e = { $_.Provider.Name } } |
    Where-Object Name -in 'Env', 'C' | Sort-Object Name
Name Provider
---- --------
C    FileSystem
Env  Environment

(Das Laufwerk C gibt es nur unter Windows; auf Linux und macOS sieht die Liste anders aus, nicht ausgeführt.) Das Laufwerk Env: zeigt die Umgebungsvariablen, und die ganz normalen Befehle funktionieren dort:

PowerShell
$env:NORDLICHT_STUFE = 'test'
Get-Item Env:NORDLICHT_STUFE | Select-Object Name, Value
Name            Value
----            -----
NORDLICHT_STUFE test

$env:NAME ist die Kurzschreibweise zum Lesen und Setzen. Die Variable gilt nur für diese Sitzung und die Prozesse, die sie startet. Get-PSDrive ohne Parameter listet alle Laufwerke, auch Function: (die Funktionen der Sitzung) und Variable:. Unter Windows kommt HKLM: und HKCU: für die Registry hinzu. Das Muster ist immer: Wer die Befehle für Dateien kennt, kennt sie für alle Provider.

Pfade: die .NET-Falle

PowerShell kennt ein aktuelles Verzeichnis: Set-Location (Alias cd) setzt es, Get-Location liest es. Die Cmdlets lösen relative Pfade gegen dieses Verzeichnis auf. Aufrufe direkt an .NET tun das nicht: Sie lösen relative Pfade gegen das Arbeitsverzeichnis des Prozesses auf, und das ist nicht das, was Set-Location gesetzt hat.

PowerShell
Set-Location $root
[IO.File]::WriteAllText('relativ.txt', 'x')
Test-Path (Join-Path $root 'relativ.txt')
Test-Path (Join-Path ([Environment]::CurrentDirectory) 'relativ.txt')
[Environment]::CurrentDirectory -eq (Get-Location).Path
False
True
False

Die Datei liegt nicht in $root, wo Set-Location hinzeigte, sondern im Arbeitsverzeichnis des Prozesses ([Environment]::CurrentDirectory). Die Regel daraus: In Aufrufen von .NET-Methoden immer absolute Pfade verwenden:

PowerShell
[IO.File]::WriteAllText((Join-Path $PWD 'richtig.txt'), 'x')
Test-Path (Join-Path $root 'richtig.txt')
True

$PWD ist die Variable für das aktuelle PowerShell-Verzeichnis, Join-Path setzt Pfadteile mit dem richtigen Trenner zusammen. Auch für die Cmdlets gilt: Skripte, die auf einem Server laufen, verlassen sich nicht darauf, wo sie gestartet wurden. Sie bauen Pfade aus einem Parameter oder aus $PSScriptRoot (dem Ordner des Skripts, mehr in der nächsten Lektion).

Zwei weitere Sorgen gehören hierher. -Path versteht Platzhalter wie * und [ ]; wer einen Dateinamen aus Daten nimmt, der solche Zeichen enthalten könnte, nimmt -LiteralPath, damit nichts als Muster gedeutet wird. Probiert: Eine Datei [a].txt liest Get-Content -LiteralPath (Ergebnis inhalt), während Get-Content -Path mit demselben Namen nichts liefert, weil [a] als Muster gilt. Und Test-Path fragt, ob etwas existiert, bevor Sie darauf zugreifen.

Dateien lesen und schreiben, Kodierung

PowerShell
$p = Join-Path $root 'umlaut.txt'
Set-Content $p 'Grüße aus Hamburg'
$b = [IO.File]::ReadAllBytes($p)
($b[0..2] | ForEach-Object { '{0:X2}' -f $_ }) -join ' '
$b.Length
Get-Content $p
47 72 C3
21
Grüße aus Hamburg

Die ersten drei Bytes sind 47 72 C3: G, r und das erste Byte von ü in UTF-8. Es steht keine Byte-Order-Mark davor. Das ist die Voreinstellung von PowerShell 7 für Set-Content: UTF-8 ohne BOM. In Windows PowerShell 5.1 ist die Voreinstellung eine andere. Derselbe Lauf mit einem ü (als Zeichen 0xFC eingegeben, damit die Quelldatei keine Rolle spielt):

7: 47 72 C3 BC 0D 0A
5: 47 72 FC 0D 0A

PowerShell 7 schreibt C3 BC (UTF-8, zwei Bytes), Windows PowerShell 5.1 schreibt FC (die ANSI-Codierung der Systemsprache, ein Byte). Beide Zeilen enden mit 0D 0A, denn Set-Content hängt auf Windows einen Zeilenumbruch an. Wer Dateien zwischen beiden Welten austauscht, legt die Kodierung fest, statt sich auf die Voreinstellung zu verlassen:

PowerShell
Set-Content $p 'Grüße' -Encoding utf8BOM

Gültige Werte sind unter anderem utf8 (ohne BOM), utf8BOM, utf8NoBOM, unicode, ascii. Als Faustregel: UTF-8 ohne BOM, ausdrücklich angegeben, wo Sie die Datei erzeugen und lesen. Ein Windows-PowerShell-5.1-Skript, dessen Quelldatei als UTF-8 ohne BOM gespeichert ist, wird von 5.1 als ANSI gelesen, und Umlaute im Skript selbst werden falsch; ein BOM in der Skriptdatei verhindert das.

Zeilenenden: Get-Content liest eine Datei Zeile für Zeile (ein Array von Zeichenketten) und kennt \r\n und \n. Mit -Raw bekommen Sie den ganzen Inhalt als eine Zeichenkette zurück, samt Zeilenenden:

PowerShell
Set-Content $p "a`r`nb`r`nc" -NoNewline
(Get-Content $p).Count
(Get-Content $p -Raw).Length
3
7

Drei Zeilen, aber sieben Zeichen im Ganzen: a, b, c und zweimal \r\n. Wer auf einem Linux-Rechner eine Datei mit Windows-Zeilenenden liest oder umgekehrt, sollte das wissen, wenn er Zeichenketten vergleicht. Der Backtick ` ist in PowerShell das Zeichen für Escape-Folgen in doppelten Anführungszeichen (`r ist Wagenrücklauf, `n Zeilenvorschub, mehr in der nächsten Lektion).

CSV

CSV ist das Austauschformat der Tabellen. Import-Csv liest eine Datei in Objekte, eine Spalte wird zur Eigenschaft:

PowerShell
$csv = Join-Path $root 'buchungen.csv'
@'
kunde,reise,preis
Nordlicht,Oslo,420.50
Nordlicht,Bergen,380
Fjord,Tromsø,999.9
'@ | Set-Content $csv
$rows = Import-Csv $csv
$rows[0].GetType().Name
$rows[0].preis.GetType().Name
PSCustomObject
String

Jede Zeile ist ein PSCustomObject, und jeder Wert ist eine Zeichenkette, auch die Zahl. Für Vergleiche und Rechnungen wandeln Sie ausdrücklich um ([decimal]):

PowerShell
$rows | Where-Object { [decimal]$_.preis -gt 400 } | Select-Object kunde, reise
($rows | ForEach-Object { [decimal]$_.preis } | Measure-Object -Sum).Sum
kunde     reise
-----     -----
Nordlicht Oslo
Fjord     Tromsø

1800,4

(wieder mit dem Dezimalkomma dieses Rechners). Ohne die Umwandlung würde -gt Zeichenketten vergleichen, und '380' -gt '400' sortiert nach Zeichen, nicht nach Wert. Export-Csv schreibt Objekte zurück:

PowerShell
$rows | Export-Csv (Join-Path $root 'aus.csv') -NoTypeInformation
Get-Content (Join-Path $root 'aus.csv')
"kunde","reise","preis"
"Nordlicht","Oslo","420.50"
"Nordlicht","Bergen","380"
"Fjord","Tromsø","999.9"

Alle Felder stehen in Anführungszeichen. In PowerShell 7 schreibt Export-Csv keine Typzeile mehr (-NoTypeInformation schadet dort nicht, ist aber nicht nötig); in Windows PowerShell 5.1 steht ohne den Schalter als erste Zeile #TYPE System.Management.Automation.PSCustomObject (so ausgeführt).

JSON

JSON ist das Format der Web-Schnittstellen und vieler Konfigurationsdateien. ConvertTo-Json macht aus Objekten Text:

PowerShell
$o = [pscustomobject]@{ name = 'Nordlicht'; reisen = @(@{ ziel = 'Oslo'; tage = 3 }); aktiv = $true }
$o | ConvertTo-Json -Depth 3
{
  "name": "Nordlicht",
  "reisen": [
    {
      "ziel": "Oslo",
      "tage": 3
    }
  ],
  "aktiv": true
}

Der Parameter -Depth ist die Falle: ConvertTo-Json geht standardmäßig nur zwei Ebenen tief und schneidet darunter ab. Bei vier verschachtelten Objekten steht dann statt der innersten Ebene nur ihre Textform:

PowerShell
$deep = [pscustomobject]@{ a = [pscustomobject]@{ b = [pscustomobject]@{ c = [pscustomobject]@{ d = 1 } } } }
$deep | ConvertTo-Json -Compress
$deep | ConvertTo-Json -Compress -Depth 5
{"a":{"b":{"c":"@{d=1}"}}}
{"a":{"b":{"c":{"d":1}}}}

Beim ersten Aufruf gibt PowerShell außerdem eine Warnung aus, dass das JSON abgeschnitten wurde (auf diesem Rechner auf Deutsch). Wer sie überliest, schreibt unvollständige Konfiguration. Die Regel: -Depth immer angeben, wenn die Objekte verschachtelt sein können. Die Gegenrichtung liest Text zu Objekten:

PowerShell
$j = '{"name":"Nordlicht","reisen":[{"ziel":"Oslo","tage":3}]}' | ConvertFrom-Json
$j.reisen[0].ziel
Oslo

Reguläre Ausdrücke und Select-String

Der Operator -match prüft eine Zeichenkette gegen einen regulären Ausdruck und füllt, wenn er passt, die automatische Variable $Matches:

PowerShell
'bericht-2025-11.txt' -match '(\d{4})-(\d{2})'
$Matches[1]
$Matches[2]

\d{4} heißt „vier Ziffern“, Klammern bilden Gruppen: $Matches[1] ist 2025, $Matches[2] ist 11. Dateien durchsucht Select-String; es gibt Treffer mit Zeilennummer zurück:

PowerShell
Set-Content (Join-Path $root 'log.txt') @('INFO ok', 'ERROR kaputt', 'INFO ok', 'ERROR noch einmal')
Select-String -Path (Join-Path $root 'log.txt') -Pattern '^ERROR' | ForEach-Object { '{0}: {1}' -f $_.LineNumber, $_.Line }
2: ERROR kaputt
4: ERROR noch einmal

^ verankert am Zeilenanfang. Mehr zu den Mustern steht in about_Regular_Expressions auf Learn.

Web-Schnittstellen: Invoke-RestMethod

Invoke-RestMethod ruft eine HTTP-Adresse auf und gibt, wenn die Antwort JSON ist, gleich Objekte zurück. Ein lokaler Test, damit Sie kein Netz brauchen: Ein winziger Server in der Sitzung antwortet einmal mit JSON.

PowerShell
$l = [System.Net.HttpListener]::new()
$l.Prefixes.Add('http://localhost:8765/'); $l.Start()
$job = Start-ThreadJob { param($l) $c = $l.GetContext(); $b = [Text.Encoding]::UTF8.GetBytes('{"status":"ok","anzahl":3}'); $c.Response.ContentType = 'application/json'; $c.Response.OutputStream.Write($b, 0, $b.Length); $c.Response.Close() } -ArgumentList $l
$r = Invoke-RestMethod http://localhost:8765/
$r.GetType().Name
$r.anzahl
$job | Wait-Job | Remove-Job; $l.Stop()
PSCustomObject
3

Die Antwort ist schon ein PSCustomObject, $r.anzahl ist 3. Das Beispiel nutzt Start-ThreadJob, um den Server im Hintergrund antworten zu lassen; Sie müssen das für den Alltag nicht verstehen. Bei echten Schnittstellen schreiben Sie einfach Invoke-RestMethod -Uri … und geben, wo nötig, -Headers und -Method an. Geheimnisse (Tokens) gehören nie in die Befehlszeile, die in ein Protokoll geraten kann: Das behandelt Lektion PS.4.2.

Übung 1: Die Pfad-Falle

  1. Legen Sie ein Verzeichnis an, wechseln Sie mit Set-Location hinein und schreiben Sie mit [IO.File]::WriteAllText('a.txt','x') eine Datei. Wo liegt sie? Prüfen Sie mit Test-Path.
  2. Schreiben Sie sie nun richtig mit Join-Path $PWD 'b.txt'.
  3. Wie lesen Sie die Datei [a].txt, ohne dass [a] als Muster gilt?

Lösung 1

  1. Sie liegt im Arbeitsverzeichnis des Prozesses ([Environment]::CurrentDirectory), nicht im neuen Ordner.
  2. [IO.File]::WriteAllText((Join-Path $PWD 'b.txt'), 'x') landet im Ordner.
  3. Get-Content -LiteralPath '[a].txt'.

Übung 2: Kodierung

  1. Schreiben Sie 'Grüße' mit Set-Content in eine Datei, lesen Sie die Bytes mit [IO.File]::ReadAllBytes und prüfen Sie, ob ein BOM (EF BB BF) vorn steht.
  2. Schreiben Sie sie noch einmal mit -Encoding utf8BOM und vergleichen Sie.
  3. Welche Kodierung wählen Sie für eine Datei, die ein anderes Team auf einem anderen System liest, und warum geben Sie sie ausdrücklich an?

Lösung 2

  1. In PowerShell 7 steht kein BOM da (47 72 C3 …).
  2. Mit utf8BOM beginnt die Datei mit EF BB BF.
  3. UTF-8, ausdrücklich: Dann hängt das Ergebnis nicht von der Voreinstellung der Version und der Systemsprache ab.

Übung 3: CSV und JSON

  1. Legen Sie die Datei buchungen.csv aus dem Abschnitt an und berechnen Sie die Summe der Preise. Warum brauchen Sie [decimal]?
  2. Wandeln Sie die Zeilen mit ConvertTo-Json in Text. Wie viele Ebenen sind es, und welches -Depth brauchen Sie mindestens?
  3. Lesen Sie den Text mit ConvertFrom-Json zurück und geben Sie das Ziel der ersten Buchung aus.

Lösung 3

  1. Summe 1800,4 (mit Dezimalkomma auf deutschem System). Die Werte sind Zeichenketten; die Umwandlung macht daraus Zahlen.
  2. Eine Liste von Objekten ist zwei Ebenen tief; geben Sie dennoch -Depth an (ein Wert von 3 oder mehr), damit spätere Änderungen nichts abschneiden.
  3. ($json | ConvertFrom-Json)[0].reise ergibt Oslo.

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

Was Sie jetzt können

  • Sie nutzen Provider und Laufwerke (Env:, Dateisystem) mit denselben Befehlen.
  • Sie geben in .NET-Aufrufen absolute Pfade an und nehmen -LiteralPath für Namen aus Daten.
  • Sie wählen die Kodierung von Dateien ausdrücklich und kennen den Unterschied zwischen PowerShell 7 und Windows PowerShell 5.1.
  • Sie lesen und schreiben CSV (Werte sind Zeichenketten) und JSON (immer mit -Depth).
  • Sie suchen mit -match und Select-String und rufen Web-Schnittstellen mit Invoke-RestMethod ab.

Damit endet das erste Modul. Im zweiten Modul schreiben Sie Ihre eigenen Skripte.

Weiterlesen