# Befehle Verschieden Befehle für PowerShell **Microsoft-Learn** - [Get-Verb](https://learn.microsoft.com/de-de/powershell/module/microsoft.powershell.core/get-verb?view=powershell-5.1 "Get-Verb | Microsoft-Learn") # Get-PSDrive Der Befehl `Get-PSDrive` gibt alle aktuell verfügbaren **PowerShell-Laufwerke (PSDrive)** zurück. Ein PSDrive stellt einen Speicherort dar, auf den PowerShell über einen einheitlichen Pfad zugreifen kann. Neben klassischen Dateisystemlaufwerken (`C:`, `D:`) gehören dazu beispielsweise auch die Registry (`HKLM:`), Zertifikate (`Cert:`), Umgebungsvariablen (`Env:`) oder Variablen (`Variable:`). --- ## Grundlagen Ein PSDrive ist **kein physisches Laufwerk**, sondern eine Abstraktion eines PowerShell-Providers. Dadurch können unterschiedliche Datenspeicher mit denselben Befehlen verwendet werden. Beispielsweise funktionieren diese Befehle alle nach dem gleichen Prinzip: ```powershell Get-ChildItem C:\ Get-ChildItem HKLM:\ Get-ChildItem Env: Get-ChildItem Variable: ``` Welcher Datenspeicher sich dahinter verbirgt, übernimmt der jeweilige Provider. --- ## Syntax ```powershell Get-PSDrive ``` Ein bestimmtes Laufwerk abrufen: ```powershell Get-PSDrive C ``` Mehrere Laufwerke: ```powershell Get-PSDrive C, D ``` Nach Provider filtern: ```powershell Get-PSDrive -PSProvider FileSystem ``` --- ## Ausgabe Die Ausgabe besteht aus Objekten vom Typ ```powershell System.Management.Automation.PSDriveInfo ``` Beispiel: ```text Name Used (GB) Free (GB) Provider Root ---- --------- --------- -------- ---- C 120.5 58.3 FileSystem C:\ Env Environment HKLM Registry Variable Variable ``` --- # Eigenschaften - Name - Provider - Root - CurrentLocation - Description - DisplayRoot - Used - Free - MaximumSize - Credential --- ## Name `[String]` Der Name des PowerShell-Laufwerks. Beispiele: ```text C D HKLM HKCU Env Variable Function Alias ``` Der Name bildet gleichzeitig den Präfix eines PowerShell-Pfades. ```powershell C:\Temp HKLM:\Software Env:PATH Variable:Error ``` --- ## Provider `[ProviderInfo]` Der PowerShell-Provider, über den auf den Speicherort zugegriffen wird. Beispiele:
ProviderBeschreibung
FileSystemDateisystem
RegistryWindows-Registry
EnvironmentUmgebungsvariablen
VariablePowerShell-Variablen
AliasAliase
FunctionFunktionen
CertificateZertifikatsspeicher
--- ## Root `[String]` Der Stammpfad des Laufwerks. Beispiele: ```text C:\ D:\ HKEY_LOCAL_MACHINE ``` Virtuelle Laufwerke besitzen häufig keinen klassischen Dateipfad. --- ## CurrentLocation `[String]` Aktuelles Arbeitsverzeichnis innerhalb des Laufwerks. Beispielsweise: ```powershell Set-Location C:\Windows (Get-PSDrive C).CurrentLocation ``` Ergebnis: ```text Windows ``` --- ## Description `[String]` Optionale Beschreibung des Laufwerks. Viele Standardlaufwerke besitzen keine Beschreibung. Selbst angelegte PSDrives können hier eine Beschreibung erhalten. --- ## DisplayRoot `[String]` Angezeigter Stammpfad. Diese Eigenschaft wird hauptsächlich bei Netzwerk- oder benutzerdefinierten Laufwerken verwendet. Bei normalen Dateisystemlaufwerken ist der Wert häufig leer. --- ## Used `[Int64]` Belegter Speicherplatz. Nur für Dateisystemlaufwerke verfügbar. Angabe erfolgt in Bytes. --- ## Free `[Int64]` Freier Speicherplatz. Nur für Dateisystemlaufwerke verfügbar. Angabe erfolgt ebenfalls in Bytes. --- ## MaximumSize `[Nullable[Int64]]` Maximal verfügbare Größe. Diese Eigenschaft wird nur von wenigen Providern genutzt und ist meistens `$null`. --- ## Credential `[PSCredential]` Anmeldedaten, mit denen das Laufwerk verbunden wurde. Bei Standardlaufwerken normalerweise `$null`. Relevant hauptsächlich für mit `New-PSDrive` eingebundene Netzlaufwerke. --- # Parameter - Name - PSProvider - Scope --- ## -Name Gibt nur bestimmte Laufwerke zurück. ```powershell Get-PSDrive C ``` Mehrere: ```powershell Get-PSDrive C, D ``` --- ## -PSProvider Filtert nach einem bestimmten Provider. Dateisystem: ```powershell Get-PSDrive -PSProvider FileSystem ``` Registry: ```powershell Get-PSDrive -PSProvider Registry ``` Alle Variablen-Laufwerke: ```powershell Get-PSDrive -PSProvider Variable ``` --- ## -Scope Zeigt Laufwerke eines bestimmten Scopes an. Dies ist hauptsächlich relevant für mit `New-PSDrive` erstellte Laufwerke. --- # Typische Beispiele Alle Laufwerke anzeigen: ```powershell Get-PSDrive ``` Nur Dateisysteme: ```powershell Get-PSDrive -PSProvider FileSystem ``` Nur Registry: ```powershell Get-PSDrive -PSProvider Registry ``` Freien Speicherplatz anzeigen: ```powershell Get-PSDrive -PSProvider FileSystem | Select-Object Name, Used, Free ``` Nur Laufwerksbuchstaben: ```powershell Get-PSDrive -PSProvider FileSystem | Select-Object -ExpandProperty Name ``` --- # Tipps & Tricks ## Dateisystemlaufwerke erkennen Nicht jedes PSDrive ist ein Festplattenlaufwerk. ```powershell Get-PSDrive -PSProvider FileSystem ``` liefert ausschließlich echte Dateisysteme. --- ## Speicherplatz in GB berechnen Die Eigenschaften `Used` und `Free` werden in Bytes zurückgegeben. ```powershell Get-PSDrive C | Select-Object Name, @{N="Used (GB)";E={[math]::Round($_.Used / 1GB,2)}}, @{N="Free (GB)";E={[math]::Round($_.Free / 1GB,2)}} ``` --- ## Mentales Modell `Get-PSDrive` zeigt **alle Speicherorte**, die PowerShell wie Laufwerke behandeln kann. Nicht jedes PSDrive ist ein Datenträger. Ein PSDrive ist lediglich die Kombination aus: - einem **Namen** (`C:`, `Env:`, `HKLM:`) - einem **Provider** - einem **Stammverzeichnis (Root)** Dadurch können Dateisysteme, Registry, Umgebungsvariablen oder Zertifikate mit denselben PowerShell-Befehlen angesprochen werden # Set-Alias Das Cmdlet `Set-Alias` erstellt oder verändert einen Alias für ein Cmdlet, eine Funktion oder einen Befehl. Ein Alias ist dabei einfach ein alternativer Kurzname für einen bestehenden Command. Es wird häufig verwendet, um: - häufig genutzte Befehle schneller aufzurufen - eigene Kurzbefehle zu definieren - bestehende Aliase umzubiegen oder anzupassen - Shell-Umgebungen individueller zu gestalten --- ## 🔧 Syntax ```powershell Set-Alias [-Name] [-Value] [-Description ] [-Option ] [-PassThru] [-Scope ] [-Force] [-WhatIf] [-Confirm] [] ``` --- ## 📌 Parameter ### `-Name` - **Typ:** `String` - **Pflicht:** Ja - Name des Alias ```powershell Set-Alias -Name ll -Value Get-ChildItem ``` --- ### `-Value` - **Typ:** `String` - **Pflicht:** Ja - Zielbefehl, auf den der Alias zeigen soll ```powershell Set-Alias -Name edit -Value notepad ``` --- ### `-Description` - **Typ:** `String` - **Pflicht:** Nein - Fügt dem Alias eine Beschreibung hinzu ```powershell Set-Alias -Name gs -Value Get-Service -Description "Listet Dienste auf" ``` --- ### `-Option` - **Typ:** `ScopedItemOptions` - **Pflicht:** Nein - Steuert das Verhalten des Alias Mögliche Optionen:
OptionBedeutung
`None`Keine besondere Einschränkung
`ReadOnly`Alias kann nur mit `-Force` geändert werden
`Constant`Alias kann gar nicht mehr geändert werden
`Private`Nur im aktuellen Scope sichtbar
```powershell Set-Alias -Name test -Value Get-Date -Option ReadOnly ``` --- ### `-PassThru` - Gibt das erstellte Alias-Objekt zurück ```powershell Set-Alias -Name now -Value Get-Date -PassThru ``` --- ### `-Scope` - Legt fest, in welchem Scope der Alias existiert Beispiele:
ScopeBedeutung
`Local`Nur aktueller Scope
`Global`Überall verfügbar
`Script`Nur innerhalb des Skripts
```powershell Set-Alias -Name ll -Value Get-ChildItem -Scope Global ``` --- ### `-Force` - Erzwingt das Überschreiben von `ReadOnly`-Aliases ```powershell Set-Alias -Name ls -Value Get-Process -Force ``` --- ## ⚠️ Hinweise zur Verwendung - Aliase speichern **keine Parameter** - Ein Alias ersetzt nur den Befehlsnamen - Aliase gelten standardmäßig nur für die aktuelle Sitzung - Für dauerhafte Aliase muss man sie ins Profil (`$PROFILE`) schreiben - `Constant`-Aliases können nicht mehr entfernt werden --- ## 📊 Verhalten
EigenschaftBeschreibung
RückgabewertStandardmäßig keiner
ÜberschreibbarJa, außer `Constant`
PersistenzNur aktuelle Sitzung
Unterstützt FunktionenJa
Unterstützt EXE-DateienJa
--- ## 🧪 Beispiele ### Einfachen Alias erstellen ```powershell Set-Alias -Name ll -Value Get-ChildItem ``` Jetzt funktioniert: ```powershell ll ``` --- ### Alias für Programme ```powershell Set-Alias -Name np -Value notepad ``` --- ### Bestehenden Alias überschreiben ```powershell Set-Alias -Name ls -Value Get-Process -Force ``` Jetzt startet `ls` plötzlich Prozesse statt Dateien aufzulisten. Ein hervorragender Weg, sich selbst drei Stunden später maximal zu verwirren. --- ### Alias dauerhaft speichern ```powershell Add-Content -Path $PROFILE -Value 'Set-Alias -Name ll -Value Get-ChildItem' ``` --- ### Alias anzeigen ```powershell Get-Alias ll ``` --- ## ⚙️ Typische Anwendungsfälle - Eigene Kurzbefehle erstellen - Linux-ähnliche Befehle nachbauen - Lange Befehlsnamen abkürzen - Eigene Shell-Umgebungen konfigurieren - Schnellzugriffe für Skripte --- ## ❗ Alternativen / Ergänzungen ### `New-Alias` ```powershell New-Alias -Name ll -Value Get-ChildItem ``` **Unterschied zu `Set-Alias`:**
CmdletVerhalten
`New-Alias`Erstellt nur neue Aliase
`Set-Alias`Erstellt oder überschreibt
--- ### Funktionen statt Alias ```powershell function ll { Get-ChildItem -Force } ``` **Vorteil:** - Kann Parameter enthalten - Deutlich flexibler - Besser für komplexe Logik --- ## 🚫 Typische Fehler ### 1. Denken, dass Aliase Parameter speichern ```powershell # ❌ Funktioniert NICHT wie erwartet Set-Alias -Name ll -Value "Get-ChildItem -Force" ``` Ein Alias verweist nur auf einen Commandnamen. Nicht auf eine komplette Befehlszeile. ➡️ Dafür nutzt man Funktionen. --- ### 2. Alias nach Neustart weg ```powershell Set-Alias -Name test -Value Get-Date ``` Nach neuer PowerShell-Sitzung verschwunden. ➡️ Alias ins `$PROFILE` schreiben. --- ### 3. Wichtige Standard-Aliase überschreiben ```powershell Set-Alias -Name cd -Value Get-Date ``` Technisch möglich. Psychologisch fragwürdig. --- ## 🧠 Best Practices - Nur sinnvolle Kurzformen verwenden - Standard-Aliase nicht leichtfertig überschreiben - Für komplexe Logik lieber Funktionen nutzen - Dauerhafte Aliase ins `$PROFILE` auslagern - In Skripten sparsam mit Aliases umgehen, damit der Code lesbar bleibt # Start-Sleep Das Cmdlet `Start-Sleep` pausiert die Ausführung eines Skripts oder einer Befehlssequenz für eine definierte Zeitspanne. Es wird häufig verwendet, um: - Wartezeiten einzubauen - Prozesse zu synchronisieren - Ressourcen zu schonen (z. B. bei Schleifen) --- ## 🔧 Syntax ```powershell Start-Sleep [-Seconds] [] Start-Sleep -Milliseconds [] ``` --- ## 📌 Parameter ### `-Seconds` - **Typ:** `Double` - **Pflicht:** Ja (wenn `-Milliseconds` nicht verwendet wird) - Gibt die Wartezeit in Sekunden an - Dezimalwerte sind erlaubt ```powershell Start-Sleep -Seconds 2.5 ``` --- ### `-Milliseconds` - **Typ:** `Int32` - **Pflicht:** Ja (wenn `-Seconds` nicht verwendet wird) - Gibt die Wartezeit in Millisekunden an ```powershell Start-Sleep -Milliseconds 500 ``` --- ## ⚠️ Hinweise zur Verwendung - `-Seconds` und `-Milliseconds` **dürfen nicht gleichzeitig verwendet werden** - Während der Ausführung blockiert `Start-Sleep` den aktuellen Thread vollständig - Es erfolgt **keine Hintergrundverarbeitung** während der Pause --- ## 📊 Verhalten
EigenschaftBeschreibung
BlockierendJa
RückgabewertKeiner
Thread-VerhaltenAktueller Thread wird pausiert
GenauigkeitAbhängig vom System-Timer
--- ## 🧪 Beispiele ### Einfaches Warten ```powershell Write-Host "Start" Start-Sleep -Seconds 2 Write-Host "Ende" ``` --- ### Verwendung in Schleifen ```powershell for ($i = 1; $i -le 5; $i++) { Write-Host "Durchlauf $i" Start-Sleep -Seconds 1 } ``` --- ### Kurze Pause in Millisekunden ```powershell Start-Sleep -Milliseconds 200 ``` --- ### Dynamische Wartezeit ```powershell $delay = 1.5 Start-Sleep -Seconds $delay ``` --- ## ⚙️ Typische Anwendungsfälle - Polling (z. B. auf Datei oder Prozess warten) - Debugging (Abläufe verlangsamen) - UI-Skripte (z. B. kurz warten, bis Controls geladen sind) - API-Rate-Limiting --- ## ❗ Alternativen / Ergänzungen ### `[System.Threading.Thread]::Sleep()` ```powershell [System.Threading.Thread]::Sleep(1000) ``` **Unterschiede:** - Arbeitet nur mit Millisekunden - Weniger PowerShell-idiomatisch - Kein Support für `CommonParameters` --- ### `Start-Sleep` vs. `Start-Job`
SzenarioEmpfehlung
Einfaches Warten`Start-Sleep`
Asynchrone Ausführung`Start-Job`
UI-Responsiveness wichtigKein `Start-Sleep`
--- ## 🚫 Typische Fehler ### 1. Beide Parameter gleichzeitig verwenden ```powershell # ❌ Falsch Start-Sleep -Seconds 1 -Milliseconds 500 ``` --- ### 2. UI einfrieren ```powershell # ❌ Problematisch in WinForms/WPF Start-Sleep -Seconds 5 ``` ➡️ Blockiert die UI komplett --- ### 3. Zu kurze Wartezeiten erwarten hohe Präzision ```powershell Start-Sleep -Milliseconds 1 ``` ➡️ Systembedingt oft ungenau --- ## 🧠 Best Practices - Für UI-Anwendungen besser Timer verwenden statt `Start-Sleep` - In Schleifen immer bewusst einsetzen, um CPU-Last zu reduzieren - Wartezeiten so kurz wie möglich halten - Für präzise Zeitsteuerung ggf. andere Mechanismen nutzen --- Wenn du das Ding in einer WinForms-App benutzt, dann frierst du dir halt elegant dein UI ein und wunderst dich danach, warum alles tot wirkt. Klassischer Anfänger-Move, aber immerhin ein lehrreicher. # Get-CimIntance Fragt Windows nach einer [CIM/WIM-Klasse](https://doku.borinas.com/books/cim-wim/chapter/cimwim-klasse) ab. --- # Syntax ```powershell Get-CimInstance ``` Nach dem Befehl `Get-CimInstance` sollte eine [CIM/WIM Klasse](https://doku.borinas.com/books/cim-wim/chapter/cimwim-klasse) genannt werden --- ## [CIM/WIM-Klasse](https://doku.borinas.com/books/cim-wim/chapter/cimwim-klasse) | Klasse | Beschreibung | | -----------------| -------------| | [Win32_CDROMDrive](https://doku.borinas.com/books/klassen/page/win32-cdromdrive) | Fragt Windows nach vorhandenen optischen Laufwerken ab | # 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` # SSH Erstellen, verwalten und das Nutzen von SSH und die Schlüssel dafür # SSH-Key ## SSH-Key erstellen Ein SSH-Schlüssel kann mit dem Befehl `ssh-keygen` erstellt werden. ```powershell ssh-keygen ``` 1. Zuerst wird nach dem Dateipfad für das Schlüssel gefragt 2. Dann wird nach einer Passphrase gefragt Normal wird das Schlüssel im Ordner `.ssh` abgespeichert. Darin befindet sich dann der Secret-Key, der keine Dateiendung hat und an niemanden weitergegeben werden sollte und den öffentlichen Schlüssel mit der Dateiendung **.pub**, der weitergegeben werden kann #### **Algorithmus** Mit dem Parameter `-t` kann der gewünschte Algorithmus angegeben werden ```powershell ssh-keygen -t ecdsa ``` Algorithmen: - **rsa** - **ed25519** - **ecdsa** #### **Größe vom Schlüssel** Mit dem Parameter `-b` kann die Bitgröße vom Schlüssel angegeben werden. ```powershell ssh-keygen -b 521 ``` Gültige Schlüsselwerte: `256`, `384` oder `521` # SSH Verbindung herstellen Stelle eine Verbindung einfach mit dem Befehl `ssh` her. Als Ziel nenne den Benutzer und den Computer/die IP-Adresse vom Ziel-Computer ```powershell ssh root@45.212.45.76 ``` Bei der ersten Verbindung kann nach der Erlaubnis gefragt werden, ob der Fingerabdruck übergeben werden soll. Einfach bestätigen mit `yes` # Get-Random Der Befehl **`Get-Random`** erzeugt einen zufälligen Wert beziehungsweise wählt zufällig ein Element aus einer angegebenen Menge aus. Mit `Get-Random` lassen sich unter anderem: * zufällige Ganzzahlen erzeugen * Zufallswerte innerhalb eines bestimmten Bereichs erzeugen * zufällig ein Element aus einer Liste auswählen * mehrere zufällige Elemente auswählen * die Reihenfolge einer Sammlung zufällig verändern * reproduzierbare Zufallsfolgen mit einem festen Seed erzeugen Der Befehl gehört zu den Standard-Cmdlets von PowerShell. --- # **Grundlagen** ### Zufällige Zahl erzeugen Wird `Get-Random` ohne weitere Parameter aufgerufen, wird eine zufällige Ganzzahl erzeugt. ```powershell Get-Random ``` Beispielausgabe: ```text 137582946 ``` Bei jedem Aufruf kann ein anderer Wert zurückgegeben werden. --- ### Zufallszahl innerhalb eines Bereichs Mit `-Minimum` und `-Maximum` lässt sich der Wertebereich festlegen. ```powershell Get-Random -Minimum 1 -Maximum 100 ``` Mögliche Ausgabe: ```text 73 ``` > **Hinweis** > > Der Wert von `-Maximum` ist **exklusiv**. Bei `-Maximum 100` können Werte von `1` bis `99` erzeugt werden. Soll beispielsweise eine Zahl zwischen **1 und 100 einschließlich** erzeugt werden, muss `-Maximum` auf `101` gesetzt werden. ```powershell Get-Random -Minimum 1 -Maximum 101 ``` --- # **Syntax** ### Zufällige Zahl ```powershell Get-Random ``` ### Zufällige Zahl mit Bereich ```powershell Get-Random -Minimum -Maximum ``` ### Zufälliges Element auswählen ```powershell Get-Random -InputObject ``` ### Mehrere zufällige Elemente auswählen ```powershell Get-Random -InputObject -Count ``` ### Sammlung zufällig mischen ```powershell Get-Random -InputObject -Shuffle ``` ### Zufallsfolge reproduzierbar machen ```powershell Get-Random -SetSeed ``` --- # **Parameter** | Parameter | Typ | Beschreibung | -------------- | ----------------- | ------------ | `-InputObject` | `Object[]` | Gibt die Objekte an, aus denen zufällig ausgewählt wird. | `-Minimum` | `Int32` | Legt die untere Grenze für eine Zufallszahl fest. | `-Maximum` | `Int32` | Legt die obere Grenze für eine Zufallszahl fest. | `-Count` | `Int32` | Gibt an, wie viele zufällige Elemente ausgewählt werden sollen. | `-Shuffle` | `SwitchParameter` | Gibt die angegebenen Elemente in zufälliger Reihenfolge zurück. | `-SetSeed` | `Int32` | Legt den Startwert des Zufallszahlengenerators fest. --- ## -InputObject ##### **Beschreibung** Der Parameter `-InputObject` gibt eine Sammlung von Objekten an, aus der `Get-Random` zufällig ein Element auswählen kann. ```powershell Get-Random -InputObject ``` Beispiel: ```powershell $Farben = "Rot", "Grün", "Blau", "Gelb" Get-Random -InputObject $Farben ``` Mögliche Ausgabe: ```text Blau ``` Bei jedem Aufruf kann eine andere Farbe ausgewählt werden. #### Beispiel mit Zahlen ```powershell $Zahlen = 10, 20, 30, 40, 50 Get-Random -InputObject $Zahlen ``` Mögliche Ausgabe: ```text 30 ``` #### Beispiel mit Strings ```powershell $Namen = "Anna", "Ben", "Clara", "David" Get-Random -InputObject $Namen ``` Mögliche Ausgabe: ```text Clara ``` > **Hinweis** > > `Get-Random` kann grundsätzlich mit beliebigen PowerShell-Objekten arbeiten, nicht nur mit Zahlen und Zeichenketten. --- ## -Minimum ##### **Beschreibung** `-Minimum` legt den kleinsten möglichen Wert einer Zufallszahl fest. ```powershell Get-Random -Minimum 10 -Maximum 20 ``` Mögliche Ausgabe: ```text 17 ``` Der Minimalwert ist **inklusiv**. Das bedeutet: ```powershell Get-Random -Minimum 10 -Maximum 20 ``` kann unter anderem `10` zurückgeben, aber niemals `20`. --- ## -Maximum ##### **Beschreibung** `-Maximum` legt die obere Grenze des Zufallsbereichs fest. Der angegebene Wert ist **exklusiv**. ```powershell Get-Random -Minimum 1 -Maximum 10 ``` Mögliche Werte: ```text 1 2 3 4 5 6 7 8 9 ``` Der Wert `10` wird nicht erzeugt. #### Zufällige Zahl zwischen 0 und einem Maximum ```powershell Get-Random -Maximum 50 ``` Mögliche werte: ```powershell 0 1 2 ... 49 ``` --- ## -Count ##### **Beschreibung** `-Count` legt fest, wie viele zufällige Elemente zurückgegeben werden sollen. ```powershell $Farben = "Rot", "Grün", "Blau", "Gelb", "Orange" Get-Random -InputObject $Farben -Count 3 ``` Mögliche Ausgabe: ```text Gelb Rot Blau ``` Die Elemente werden dabei standardmäßig ohne Wiederholung aus der Sammlung ausgewählt. #### Beispiel ```powershell $Zahlen = 1..10 Get-Random -InputObject $Zahlen -Count 3 ``` Mögliche Ausgabe: ```text 7 2 9 ``` > **Hinweis** > > `-Count` bezieht sich auf die Anzahl der zurückgegebenen Elemente, nicht auf die Anzahl der durchzuführenden Zufallsoperationen. --- ## -Shuffle ##### **Beschreibung** `-Shuffle` gibt alle über `-InputObject` übergebenen Elemente in einer zufälligen Reihenfolge zurück. ```powershell $Zahlen = 1..10 Get-Random -InputObject $Zahlen -Shuffle ``` Mögliche Ausgabe: ```text 4 9 1 7 3 10 2 8 5 6 ``` Alle Elemente bleiben erhalten, lediglich ihre Reihenfolge wird verändert. #### Beispiel mit Namen ```powershell $Namen = "Anna", "Ben", "Clara", "David" Get-Random -InputObject $Namen -Shuffle ``` Mögliche Ausgabe: ```text Clara Anna David Ben ``` Das ist praktisch, wenn beispielsweise eine Liste zufällig sortiert werden soll. --- ## -SetSeed ##### **Beschreibung** Mit `-SetSeed` kann der Startwert des Zufallszahlengenerators festgelegt werden. ```powershell Get-Random -SetSeed 12345 ``` Der Seed beeinflusst die erzeugte Zufallsfolge. Ein identischer Seed kann dazu verwendet werden, eine reproduzierbare Zufallsfolge zu erzeugen. ```powershell Get-Random -SetSeed 12345 ``` Anschließend erzeugte Zufallswerte folgen dann derselben deterministischen Sequenz. > **Hinweis** > > Ein fester Seed bedeutet nicht, dass die Werte tatsächlich zufällig und unvorhersehbar sind. Für kryptografische Zwecke ist `Get-Random` daher nicht geeignet. Zufall ist schließlich nicht automatisch Sicherheit, auch wenn Menschen das erstaunlich gerne verwechseln. --- # **Beispiele** ## Zufällige Zahlen #### **Zahl zwischen 0 und einem Maximum** ```powershell Get-Random -Maximum 50 ``` Mögliche Werte: ```powershell 0 1 2 ... 49 ``` --- #### **Zahl zwischen zwei Grenzen** ```powershell Get-Random -Minimum 50 -Maximum 100 ``` Mögliche Werte: ```text 50 51 52 ... 99 ``` --- #### **Zufällige Würfelzahl** Ein Würfel besitzt die Werte `1` bis `6`. ```powershell Get-Random -Minimum 1 -Maximum 7 ``` Mögliche Ausgabe: ```text 4 ``` ##### Mehrfach würfeln ```powershell 1..10 | ForEach-Object { Get-Random -Minimum 1 -Maximum 7 } ``` Mögliche Ausgabe: ```text 3 6 1 4 2 6 5 3 1 4 ``` --- ## Zufällige Elemente auswählen #### **Zufälliges Element aus einem Array** ```powershell $Tiere = "Hund", "Katze", "Maus", "Pferd" Get-Random -InputObject $Tiere ``` Mögliche Ausgabe: ```text Katze ``` --- #### **Zufälliges Element aus einer Pipeline** `Get-Random` kann auch Objekte aus der Pipeline entgegennehmen. ```powershell "Rot", "Grün", "Blau", "Gelb" | Get-Random ``` Mögliche Ausgabe: ```text Grün ``` Das funktioniert beispielsweise auch mit Dateien: ```powershell Get-ChildItem | Get-Random ``` Hier wird eine zufällige Datei beziehungsweise ein zufälliges Verzeichnis aus dem aktuellen Verzeichnis ausgewählt. --- #### **Zufällige Datei auswählen** ```powershell Get-ChildItem "C:\Temp" -File | Get-Random ``` Damit wird ein zufälliges Dateiobjekt aus `C:\Temp` ausgewählt. --- #### **Zufälligen Namen auswählen** ```powershell $Namen = @( "Anna" "Ben" "Clara" "David" "Eva" ) $Name = $Namen | Get-Random $Name ``` Mögliche Ausgabe: ```text David ``` --- ## Mehrere Elemente auswählen Mit `-Count` können mehrere Elemente aus einer Sammlung ausgewählt werden. ```powershell $Namen = "Anna", "Ben", "Clara", "David", "Eva" Get-Random -InputObject $Namen -Count 2 ``` Mögliche Ausgabe: ```text David Anna ``` --- #### **Drei zufällige Dateien auswählen** ```powershell Get-ChildItem "C:\Temp" -File | Get-Random -Count 3 ``` Damit werden drei zufällige Dateien ausgewählt. --- ## Listen zufällig mischen Eine Sammlung kann mit `-Shuffle` vollständig durchmischt werden. ```powershell $Karten = 1..10 $Karten | Get-Random -Shuffle ``` Mögliche Ausgabe: ```text 7 2 10 4 1 9 6 3 8 5 ``` #### Alternative mit `-Count` Wenn eine bestimmte Anzahl zufälliger Elemente benötigt wird: ```powershell $Karten | Get-Random -Count 3 ``` Mögliche Ausgabe: ```text 8 2 5 ``` ### Zufälligen Benutzer auswählen ```powershell $Benutzer = @( "Anna" "Ben" "Clara" "David" ) $Zufall = $Benutzer | Get-Random Write-Host "Ausgewählt: $Zufall" ``` --- ### Zufällige Farbe auswählen ```powershell $Farben = @( "Red" "Green" "Blue" "Yellow" ) $Farbe = $Farben | Get-Random Write-Host "Farbe: $Farbe" ``` --- ### Zufällige Zahl für einen Bereich ```powershell $Zahl = Get-Random -Minimum 1 -Maximum 101 Write-Host "Zufallszahl: $Zahl" ``` --- ### Zufällige Datei auswählen ```powershell $Datei = Get-ChildItem "C:\Temp" -File | Get-Random Write-Host "Ausgewählte Datei: $($Datei.Name)" ``` --- ### Zufällige Reihenfolge erzeugen ```powershell $Teilnehmer = @( "Anna" "Ben" "Clara" "David" "Eva" ) $Teilnehmer | Get-Random -Shuffle ``` Mögliche Ausgabe: ```text Clara Eva Anna David Ben ``` --- ## Häufige Einsatzgebiete `Get-Random` wird häufig verwendet für: * Zufallszahlen * Würfelsimulationen * zufällige Auswahl aus Listen * zufällige Dateien oder Verzeichnisse * Testdaten * Simulationen * Spiele * zufällige Reihenfolgen * Auswahl von Testfällen * einfache Zufallsentscheidungen --- # **Rückgabewerte** Der Rückgabewert hängt davon ab, welche Eingabe verwendet wird. | Verwendung | Rückgabewert | | -------------- | ------------------------------------------------------------- | | Zufallszahl | `System.Int32` bzw. numerischer Datentyp | | `-InputObject` | Typ des ausgewählten Objekts | | `-Count` | Mehrere Objekte | | `-Shuffle` | Sammlung der ursprünglichen Objekte in zufälliger Reihenfolge | Beispiel: ```powershell $Wert = Get-Random -Minimum 1 -Maximum 100 $Wert.GetType().FullName ``` Mögliche Ausgabe: ```text System.Int32 ``` Bei Objekten bleibt deren ursprünglicher Typ erhalten. --- # **Hinweise** ### `-Maximum` ist exklusiv Bei: ```powershell Get-Random -Minimum 1 -Maximum 10 ``` liegt der Wertebereich zwischen `1` und `9`. Für `1` bis `10` muss daher verwendet werden: ```powershell Get-Random -Minimum 1 -Maximum 11 ``` --- ### `Get-Random` ist nicht für Kryptografie geeignet `Get-Random` sollte nicht verwendet werden, wenn kryptografisch sichere Zufallswerte benötigt werden. Für sicherheitsrelevante Anwendungen müssen dafür geeignete kryptografische Zufallszahlengeneratoren verwendet werden. --- ### Zufälligkeit ist nicht Gleichverteilung in kleinen Stichproben Auch wenn eine Zufallsfunktion verwendet wird, bedeutet das nicht, dass in einer kleinen Anzahl von Durchläufen jedes Ergebnis gleich häufig erscheint. Beispielsweise kann: ```powershell 1..10 | ForEach-Object { Get-Random -Minimum 1 -Maximum 7 } ``` zufällig fünfmal die `3` liefern. Das ist kein Fehler. Zufall ist lediglich bemerkenswert schlecht darin, menschliche Erwartungen an "ausgewogen" zu erfüllen. --- # Kurzreferenz | Aufgabe | Befehl | | ---------------------------- | ------------------------------------ | | Zufällige Zahl erzeugen | `Get-Random` | | Zahl bis 99 erzeugen | `Get-Random -Maximum 100` | | Zahl von 1 bis 100 | `Get-Random -Minimum 1 -Maximum 101` | | Zufälliges Element auswählen | `$Liste \| Get-Random` | | Mehrere Elemente auswählen | `$Liste \| Get-Random -Count 3` | | Liste mischen | `$Liste \| Get-Random -Shuffle` | | Seed setzen | `Get-Random -SetSeed 123` | --- ## Siehe auch * `Get-Random` * `System.Random` * `System.Security.Cryptography.RandomNumberGenerator` * `ForEach-Object` * `Select-Object`