# Path # Join-Path Das Cmdlet `Join-Path` kombiniert mehrere Pfadsegmente zu einem gültigen Dateisystempfad. Es wird verwendet, um: - Pfade plattformunabhängig zusammenzusetzen - manuelles Hantieren mit Trennzeichen (`\` oder `/`) zu vermeiden - Fehler durch doppelte oder fehlende Separatoren zu verhindern --- # **Syntax** ```powershell Join-Path [-Path] [-ChildPath] [[-AdditionalChildPath] ] [] ``` | Parameter | Typ | Beschreibung | --------- | --- | - | `Path` | `String` | Basispfad (z. B. Verzeichnis) | `ChildPath` | `String` | Pfadsegment, das an `-Path` angehängt wird | `AdditionalChildPath` | `String[]` | Weitere Pfadsegmente, die nacheinander angehängt werden

Der Parameter AdditionalChildPath ist ab PowerShell 6+ verfügbar.

--- ## Hinweise zur Verwendung - Trennzeichen werden automatisch korrekt gesetzt (kein manuelles `\` nötig) - Funktioniert providerübergreifend (z. B. Registry, Zertifikate) - Mehrere Segmente werden sauber zusammengeführt - Bestehende Trennzeichen im Input werden berücksichtigt (keine doppelten `\\`) --- ## Verhalten
EigenschaftBeschreibung
PlattformabhängigkeitBerücksichtigt das jeweilige Dateisystem
Rückgabewert`String` (zusammengesetzter Pfad)
ValidierungKeine Existenzprüfung des Pfades
Separator-HandlingAutomatisch korrekt
--- ## Beispiele ### Einfaches Zusammenfügen ```powershell Join-Path -Path "C:\Temp" -ChildPath "Datei.txt" ``` Ergebnis: `C:\Temp\Datei.txt` --- ### Mehrere Segmente ```powershell Join-Path -Path "C:\Temp" -ChildPath "Logs" -AdditionalChildPath "2026","April" ``` Ergebnis: `C:\Temp\Logs\2026\April` --- ### Mit Variablen ```powershell $base = "C:\Temp" $file = "report.txt" Join-Path -Path $base -ChildPath $file ``` Ergebnis: `C:\Temp\report.txt` --- ### Provider-unabhängig (z. B. Registry) ```powershell Join-Path -Path "HKCU:\Software" -ChildPath "Microsoft" ``` --- ## ⚙️ Typische Anwendungsfälle - Dynamische Dateipfade erstellen - Arbeiten mit temporären Verzeichnissen - Plattformunabhängige Skripte schreiben - Zusammenbau von Registry-Pfaden --- ## ❗ Alternativen / Ergänzungen ### `String`-Konkatenation ```powershell # ❌ Fehleranfällig "C:\Temp\" + "Datei.txt" ``` - Fehleranfällig bei fehlenden oder doppelten Trennzeichen - Nicht plattformunabhängig --- ### `[System.IO.Path]::Combine()` ```powershell [System.IO.Path]::Combine("C:\Temp", "Datei.txt") ``` **Unterschiede:** - .NET-Methode, nicht PowerShell-spezifisch - Keine Provider-Unterstützung (nur Dateisystem) - Kein Support für `CommonParameters` --- ## 🧠 Best Practices - Immer `Join-Path` statt String-Konkatenation verwenden - Ab PowerShell 6 kann für mehrere Segmente `-AdditionalChildPath` verwendet werden. - Kombination mit `Test-Path` für Existenzprüfung - Variablen statt Hardcoding verwenden --- Wenn du Pfade immer noch per String zusammenklebst, dann sabotierst du dich halt selbst mit Ansage. Funktioniert kurz, bricht später, und dann suchst du den Fehler wie ein Detektiv ohne Kaffee. Nimm einfach `Join-Path` und erspar dir das Drama. # Split-Path `Split-Path` zerlegt einen Pfad in einzelne Bestandteile oder gibt gezielt einen bestimmten Bestandteil eines Pfades zurück. Der Befehl kann beispielsweise verwendet werden, um aus einem vollständigen Dateipfad nur den **Ordner**, den **Dateinamen** oder den **übergeordneten Pfad** zu ermitteln. --- # Grundlagen ## Syntax ```powershell Split-Path [-Path] [-Qualifier] [-NoQualifier] [-Parent] [-Leaf] [-Resolve] [-Credential ] ``` Alternativ kann ein Pfad über `-LiteralPath` angegeben werden: ```powershell Split-Path [-LiteralPath] [-Qualifier] [-NoQualifier] [-Parent] [-Leaf] [-Resolve] [-Credential ] ``` Der wichtigste Unterschied zwischen `-Path` und `-LiteralPath` besteht darin, dass `-Path` Wildcards interpretiert, während `-LiteralPath` den angegebenen Pfad exakt verwendet. --- ## Beschreibung `Split-Path` arbeitet ausschließlich mit der **Struktur eines Pfades**. Der Befehl greift dabei nicht grundsätzlich auf das Dateisystem zu. Beispielsweise: ```powershell Split-Path "C:\Users\Jonny\Dokumente\Test.txt" ``` Ausgabe: ```text C:\Users\Jonny\Dokumente ``` Ohne weitere Angabe wird standardmäßig der **übergeordnete Pfad** zurückgegeben. Je nach verwendeter Option kann `Split-Path` aber auch andere Bestandteile ermitteln: | Option | Ergebnis | | -------------- | ------------------------------------- | | keine Option | Übergeordneter Pfad | | `-Parent` | Übergeordneter Pfad | | `-Leaf` | Letzter Bestandteil des Pfades | | `-Qualifier` | Laufwerk bzw. Pfadqualifizierer | | `-NoQualifier` | Pfad ohne Laufwerk bzw. Qualifizierer | | `-Resolve` | Aufgelöster Pfad | --- # Parameter | Parameter | Typ | Beschreibung | | -------------- | ----------------- | --------------------------------------------------------------------------------------- | | `-Path` | `String[]` | Gibt den zu zerlegenden Pfad an. Wildcards werden unterstützt. | | `-LiteralPath` | `String[]` | Gibt den Pfad exakt an. Wildcards werden nicht interpretiert. | | `-Parent` | `SwitchParameter` | Gibt den übergeordneten Bestandteil des Pfades zurück. | | `-Leaf` | `SwitchParameter` | Gibt den letzten Bestandteil des Pfades zurück. | | `-Qualifier` | `SwitchParameter` | Gibt den Qualifizierer des Pfades zurück, beispielsweise `C:`. | | `-NoQualifier` | `SwitchParameter` | Entfernt den Qualifizierer aus dem Pfad. | | `-Resolve` | `SwitchParameter` | Löst den Pfad auf und gibt den tatsächlichen Pfad zurück. | | `-Credential` | `PSCredential` | Gibt die Anmeldeinformationen an, die beim Auflösen des Pfades verwendet werden sollen. | --- # Bestandteile eines Pfades ## Parent `-Parent` gibt den übergeordneten Pfad zurück. ```powershell Split-Path "C:\Users\Jonny\Dokumente\Test.txt" -Parent ``` Ausgabe: ```text C:\Users\Jonny\Dokumente ``` Das entspricht auch dem Standardverhalten von `Split-Path`: ```powershell Split-Path "C:\Users\Jonny\Dokumente\Test.txt" ``` --- ## Leaf `-Leaf` gibt den letzten Bestandteil des Pfades zurück. Bei einem Dateipfad ist dies normalerweise der **Dateiname**. ```powershell Split-Path "C:\Users\Jonny\Dokumente\Test.txt" -Leaf ``` Ausgabe: ```text Test.txt ``` Bei einem Ordnerpfad wird entsprechend der letzte Ordner zurückgegeben: ```powershell Split-Path "C:\Users\Jonny\Dokumente" -Leaf ``` Ausgabe: ```text Dokumente ``` --- ## Qualifier `-Qualifier` gibt den Qualifizierer eines Pfades zurück. Bei einem lokalen Windows-Pfad ist dies normalerweise das Laufwerk: ```powershell Split-Path "C:\Users\Jonny\Dokumente\Test.txt" -Qualifier ``` Ausgabe: ```text C: ``` Bei anderen Pfadtypen kann der Qualifizierer entsprechend anders aussehen. --- ## NoQualifier `-NoQualifier` entfernt den Qualifizierer aus dem Pfad. ```powershell Split-Path "C:\Users\Jonny\Dokumente\Test.txt" -NoQualifier ``` Ausgabe: ```text \Users\Jonny\Dokumente\Test.txt ``` Damit kann beispielsweise ein Pfad ohne Laufwerksbuchstaben erzeugt werden. --- # Wildcards Der Parameter `-Path` unterstützt Wildcards. Beispielsweise: ```powershell Split-Path "C:\Users\Jonny\*.txt" -Leaf ``` Dabei wird `*.txt` als Wildcard interpretiert. Soll der Pfad dagegen **wörtlich** behandelt werden, wird `-LiteralPath` verwendet: ```powershell Split-Path -LiteralPath "C:\Users\Jonny\*.txt" -Leaf ``` Hier wird `*.txt` nicht als Platzhalter interpretiert. > 💡 **Hinweis** > Der Unterschied zwischen `-Path` und `-LiteralPath` ist besonders relevant, wenn ein Pfad Zeichen enthält, die PowerShell als Wildcards interpretiert. --- # Resolve Mit `-Resolve` wird der angegebene Pfad aufgelöst. ```powershell Split-Path "C:\Users\Jonny\Dokumente\..\Test.txt" -Resolve ``` Dadurch kann beispielsweise ein Pfad mit relativen Bestandteilen wie `..` auf seinen tatsächlichen Pfad reduziert werden. `-Resolve` arbeitet dabei mit dem PowerShell-Provider-System und kann deshalb auch für andere Provider als das Dateisystem relevant sein. --- # Mehrere Pfade `Split-Path` akzeptiert mehrere Pfade über `-Path`. ```powershell $paths = @( "C:\Test\Datei1.txt" "C:\Test\Datei2.txt" "C:\Test\Datei3.txt" ) Split-Path $paths -Leaf ``` Ausgabe: ```text Datei1.txt Datei2.txt Datei3.txt ``` Das ist besonders praktisch, wenn mehrere Pfade aus einer Pipeline oder einer Variablen verarbeitet werden sollen. --- # Verwendung mit der Pipeline `Split-Path` kann Pfade auch über die Pipeline verarbeiten. ```powershell Get-ChildItem "C:\Test" | Split-Path -Parent ``` Da `Get-ChildItem` Objekte liefert, ist bei komplexeren Szenarien häufig die explizite Übergabe des Pfades sinnvoll: ```powershell Get-ChildItem "C:\Test" | ForEach-Object { Split-Path $_.FullName -Parent } ``` Hier wird für jedes gefundene Objekt dessen vollständiger Pfad an `Split-Path` übergeben. --- # Typische Anwendungsfälle `Split-Path` wird häufig verwendet, um: * den Ordner einer Datei zu ermitteln * den Dateinamen aus einem Pfad zu extrahieren * den Laufwerksbuchstaben zu bestimmen * Pfade ohne Laufwerksbuchstaben zu erzeugen * Pfade vor der weiteren Verarbeitung zu zerlegen * mehrere Pfade automatisiert zu verarbeiten Ein typisches Beispiel ist das Ermitteln des Verzeichnisses einer Datei: ```powershell $file = "C:\Users\Jonny\Dokumente\Test.txt" $directory = Split-Path $file -Parent $directory ``` Ausgabe: ```text C:\Users\Jonny\Dokumente ``` --- # Rückgabewert `Split-Path` gibt einen oder mehrere **Strings** zurück. Der genaue Inhalt hängt von der verwendeten Option ab. | Option | Beispiel | Rückgabe | | -------------- | ------------------- | ----------------- | | `-Parent` | `C:\Test\Datei.txt` | `C:\Test` | | `-Leaf` | `C:\Test\Datei.txt` | `Datei.txt` | | `-Qualifier` | `C:\Test\Datei.txt` | `C:` | | `-NoQualifier` | `C:\Test\Datei.txt` | `\Test\Datei.txt` | | `-Resolve` | auflösbarer Pfad | Aufgelöster Pfad | --- # Beispiele ## Dateiname ermitteln ```powershell $path = "C:\Projekte\Projekt1\script.ps1" Split-Path $path -Leaf ``` Ausgabe: ```text script.ps1 ``` ## Verzeichnis ermitteln ```powershell Split-Path $path -Parent ``` Ausgabe: ```text C:\Projekte\Projekt1 ``` ## Laufwerk ermitteln ```powershell Split-Path $path -Qualifier ``` Ausgabe: ```text C: ``` ## Pfad ohne Laufwerk ```powershell Split-Path $path -NoQualifier ``` Ausgabe: ```text \Projekte\Projekt1\script.ps1 ``` --- # Hinweise * `Split-Path` **zerlegt Pfade**, anstatt Dateien oder Ordner zu verändern. * Ohne eine entsprechende Option wird standardmäßig der **Parent-Pfad** zurückgegeben. * `-Leaf` eignet sich besonders zum Ermitteln eines Dateinamens. * `-Parent` eignet sich zum Ermitteln des Verzeichnisses einer Datei. * `-Path` unterstützt Wildcards. * `-LiteralPath` behandelt den angegebenen Pfad wörtlich. * Mit `-Resolve` kann ein Pfad tatsächlich aufgelöst werden. * Der Befehl arbeitet mit dem **PowerShell-Provider-System** und ist deshalb nicht ausschließlich auf das Dateisystem beschränkt. --- # Siehe auch * `Join-Path` * `Resolve-Path` * `Convert-Path` * `Get-Item` * `Get-ChildItem`