Powershell - Die Pipeline und Objektverarbeitung
Modul 2.1: Das Pipeline-Prinzip
Was ist die Pipeline?
Die Pipeline ist das Herzstück von PowerShell. Sie verbindet Cmdlets mit dem Pipe-Symbol (|) und übergibt Objekte von einem Cmdlet zum nächsten.
Wichtig: PowerShell übergibt keine Text-Strings wie CMD oder Bash, sondern vollständige .NET-Objekte mit Eigenschaften und Methoden!
Einfaches Pipeline-Beispiel
# Prozesse abrufen und nach CPU sortieren
Get-Process | Sort-Object CPU
Was passiert hier?
Get-Processerstellt Process-Objekte|übergibt diese ObjekteSort-Objectsortiert sie nach der CPU-Eigenschaft
Pipeline vs. Text
| Traditionelle Shell (CMD/Bash) | PowerShell |
|---|---|
| Übergibt Text-Zeilen | Übergibt Objekte |
| Parsing mit grep, awk, sed | Direkte Objekt-Manipulation |
| Unstrukturierte Daten | Strukturierte Daten |
| Fehleranfällig bei Format-Änderungen | Robust durch Objekt-Eigenschaften |
Beispiel CMD vs. PowerShell:
# CMD/Bash - Text-basiert
dir | findstr ".txt"
# PowerShell - Objekt-basiert
Get-ChildItem | Where-Object Extension -eq ".txt"
Pipeline-Visualisierung
Get-Service | Where-Object Status -eq 'Running' | Sort-Object Name | Select-Object -First 5
Ablauf:
Get-Service
↓ (ServiceController-Objekte)
Where-Object Status -eq 'Running'
↓ (Gefilterte ServiceController-Objekte)
Sort-Object Name
↓ (Sortierte ServiceController-Objekte)
Select-Object -First 5
↓ (Top 5 ServiceController-Objekte)
Ausgabe
Modul 2.2: Objekte untersuchen mit Get-Member
Was sind Objekte?
In PowerShell ist alles ein Objekt. Jedes Objekt hat:
- Eigenschaften (Properties) - Daten/Attribute
- Methoden (Methods) - Funktionen/Aktionen
Get-Member: Das Schweizer Taschenmesser
Get-Member (Alias: gm) zeigt dir alle Eigenschaften und Methoden eines Objekts:
# Struktur von Process-Objekten anzeigen
Get-Process | Get-Member
# Nur Eigenschaften
Get-Process | Get-Member -MemberType Property
# Nur Methoden
Get-Process | Get-Member -MemberType Method
Beispiel: Process-Objekt analysieren
Get-Process | Select-Object -First 1 | Get-Member
Ausgabe (Auszug):
TypeName: System.Diagnostics.Process
Name MemberType Definition
---- ---------- ----------
Handles Property int Handles {get;}
Id Property int Id {get;}
ProcessName Property string ProcessName {get;}
StartTime Property datetime StartTime {get;}
Kill Method void Kill()
Start Method bool Start()
Eigenschaften verwenden
# Einzelne Eigenschaft abrufen
(Get-Process -Name "notepad").Id
# Mehrere Eigenschaften
Get-Process | Select-Object Name, Id, CPU
# Berechnete Eigenschaften
Get-Process | Select-Object Name,
@{Name="Memory(MB)"; Expression={$_.WorkingSet / 1MB}}
Methoden aufrufen
# String-Methoden
"Hallo Welt".ToUpper() # HALLO WELT
"Hallo Welt".Replace("Welt", "PowerShell") # Hallo PowerShell
# DateTime-Methoden
(Get-Date).AddDays(7) # Datum in 7 Tagen
(Get-Date).DayOfWeek # Wochentag
# Process-Methoden (Vorsicht!)
$prozess = Get-Process notepad
$prozess.Kill() # Beendet Notepad
Kill() - sie führen Aktionen aus!Modul 2.3: Filtern mit Where-Object
Grundlegende Filterung
Where-Object (Alias: where, ?) filtert Objekte basierend auf Bedingungen:
# Dienste die laufen
Get-Service | Where-Object Status -eq 'Running'
# Prozesse mit mehr als 100 MB Arbeitsspeicher
Get-Process | Where-Object WorkingSet -gt 100MB
# Dateien größer als 1 MB
Get-ChildItem | Where-Object Length -gt 1MB
Vergleichsoperatoren
| Operator | Bedeutung | Beispiel |
|---|---|---|
-eq |
Gleich (equal) | Where-Object Status -eq 'Running'
|
-ne |
Ungleich (not equal) | Where-Object Name -ne 'System'
|
-gt |
Größer als (greater than) | Where-Object CPU -gt 100
|
-ge |
Größer oder gleich | Where-Object Length -ge 1MB
|
-lt |
Kleiner als (less than) | Where-Object Id -lt 1000
|
-le |
Kleiner oder gleich | Where-Object Priority -le 5
|
-like |
Wildcard-Vergleich | Where-Object Name -like "*.txt"
|
-notlike |
Nicht wie | Where-Object Name -notlike "test*"
|
-match |
Regex-Vergleich | Where-Object Name -match "^[A-Z]"
|
-notmatch |
Nicht matchen | Where-Object Extension -notmatch "\.tmp$"
|
-contains |
Array enthält | Where-Object {$array -contains $_.Name}
|
-in |
Element in Array | Where-Object Status -in @('Running','Stopped')
|
Script-Block-Syntax
Für komplexere Bedingungen verwendest du Script-Blocks mit $_ (aktuelles Pipeline-Objekt):
# Mehrere Bedingungen mit -and
Get-Process | Where-Object {$_.CPU -gt 10 -and $_.WorkingSet -gt 50MB}
# Alternative: -or
Get-Service | Where-Object {$_.Status -eq 'Running' -or $_.StartType -eq 'Automatic'}
# Negation mit -not oder !
Get-ChildItem | Where-Object {-not $_.PSIsContainer} # Nur Dateien
# Komplexe Bedingung
Get-Process | Where-Object {
$_.Name -like "chrome*" -and
$_.WorkingSet -gt 100MB -and
$_.Responding -eq $true
}
Vereinfachte Syntax (ab PowerShell 3.0)
# Kurz und lesbar
Get-Service | Where-Object Status -eq 'Running'
# Entspricht der Script-Block-Syntax
Get-Service | Where-Object {$_.Status -eq 'Running'}
Modul 2.4: Auswählen mit Select-Object
Eigenschaften auswählen
Select-Object (Alias: select) wählt bestimmte Eigenschaften aus:
# Nur Name und CPU
Get-Process | Select-Object Name, CPU
# Erste 10 Ergebnisse
Get-Process | Select-Object -First 10
# Letzte 5 Ergebnisse
Get-Service | Select-Object -Last 5
# Alle außer ersten 3
Get-ChildItem | Select-Object -Skip 3
# Duplikate entfernen
Get-Process | Select-Object ProcessName -Unique
Berechnete Eigenschaften
Erstelle eigene Eigenschaften mit Hashtables:
# Memory in MB statt Bytes
Get-Process | Select-Object Name,
@{Name='MemoryMB'; Expression={[math]::Round($_.WorkingSet / 1MB, 2)}}
# Mehrere berechnete Eigenschaften
Get-Process | Select-Object Name,
@{N='CPU(s)'; E={$_.CPU}},
@{N='Memory(MB)'; E={[math]::Round($_.WS / 1MB, 2)}},
@{N='Running'; E={if($_.Responding){"Ja"}else{"Nein"}}}
Name kann zu N und Expression zu E abgekürzt werden.Eigenschaften erweitern
# Alle Eigenschaften anzeigen (auch versteckte)
Get-Process | Select-Object -Property *
# Bestimmte und alle anderen
Get-Process | Select-Object Name, Id, *
Modul 2.5: Sortieren mit Sort-Object
Grundlegendes Sortieren
Sort-Object (Alias: sort) sortiert Objekte:
# Nach Name sortieren (aufsteigend)
Get-Process | Sort-Object Name
# Absteigend sortieren
Get-Process | Sort-Object CPU -Descending
# Nach mehreren Eigenschaften
Get-Service | Sort-Object Status, Name
# Zahlen vs. Text
Get-ChildItem | Sort-Object Length -Descending
Erweiterte Sortierung
# Case-sensitive
Get-ChildItem | Sort-Object Name -CaseSensitive
# Eindeutige Werte
Get-Process | Sort-Object ProcessName -Unique
# Erst nach Status (absteigend), dann nach Name (aufsteigend)
Get-Service | Sort-Object @{Expression="Status"; Descending=$true},
@{Expression="Name"; Descending=$false}
Top-N-Pattern
Häufiges Muster: Sortieren und Top-N auswählen:
# Top 10 Prozesse nach CPU
Get-Process | Sort-Object CPU -Descending | Select-Object -First 10
# Top 5 größte Dateien
Get-ChildItem | Sort-Object Length -Descending | Select-Object -First 5 Name, Length
# Älteste 3 Dienste (nach StartTime)
Get-Service | Sort-Object StartTime | Select-Object -First 3
Modul 2.6: Messen mit Measure-Object
Statistiken berechnen
Measure-Object (Alias: measure) berechnet Statistiken:
# Anzahl der Prozesse
Get-Process | Measure-Object
# Summe aller CPU-Zeit
Get-Process | Measure-Object -Property CPU -Sum
# Durchschnittliche Dateigröße
Get-ChildItem | Measure-Object -Property Length -Average
# Alle Statistiken auf einmal
Get-Process | Measure-Object -Property WorkingSet -Sum -Average -Maximum -Minimum
Praktische Beispiele
# Anzahl laufender Dienste
(Get-Service | Where-Object Status -eq 'Running' | Measure-Object).Count
# Gesamtgröße aller Dateien in einem Ordner
$total = Get-ChildItem C:\Temp -Recurse |
Measure-Object -Property Length -Sum
"Gesamtgröße: $([math]::Round($total.Sum / 1GB, 2)) GB"
# Durchschnittliche CPU-Auslastung der Top-10-Prozesse
Get-Process | Sort-Object CPU -Descending |
Select-Object -First 10 |
Measure-Object -Property CPU -Average
Zeichen, Wörter, Zeilen zählen
# Wie Linux 'wc' (word count)
Get-Content text.txt | Measure-Object -Line -Word -Character
Modul 2.7: Ausgabe formatieren
Die Format-Cmdlets
PowerShell bietet verschiedene Format-Cmdlets für die Ausgabe:
| Cmdlet | Beschreibung | Verwendung |
|---|---|---|
Format-Table |
Tabellenformat | Standard, übersichtlich für Listen |
Format-List |
Listenformat | Detailliert, eine Eigenschaft pro Zeile |
Format-Wide |
Spaltenformat | Nur eine Eigenschaft, mehrere Spalten |
Format-Custom |
Benutzerdefiniert | Selten verwendet |
Format-Table (ft)
# Standard-Tabelle
Get-Process | Format-Table
# Bestimmte Spalten
Get-Process | Format-Table Name, CPU, WorkingSet
# AutoSize für bessere Darstellung
Get-Process | Format-Table Name, CPU, Id -AutoSize
# Mit Gruppierung
Get-Service | Format-Table -GroupBy Status
# Berechnete Spalten
Get-Process | Format-Table Name,
@{Label="Memory(MB)"; Expression={$_.WS / 1MB}; FormatString="F2"; Alignment="Right"}
Format-List (fl)
# Alle Eigenschaften als Liste
Get-Process -Name "powershell" | Format-List *
# Bestimmte Eigenschaften
Get-Service -Name "wuauserv" | Format-List Name, Status, StartType, DisplayName
# Ideal für einzelne Objekte mit vielen Eigenschaften
Get-ComputerInfo | Format-List
Format-Wide (fw)
# Nur Namen in Spalten
Get-Process | Format-Wide Name
# Anzahl der Spalten festlegen
Get-Process | Format-Wide Name -Column 5
# Nützlich für Übersichten
Get-Command | Format-Wide Name -Column 4
Out-Cmdlets
Für Ausgabe-Umleitung gibt es Out-* Cmdlets:
# In Datei schreiben
Get-Process | Out-File prozesse.txt
# An Datei anhängen
Get-Service | Out-File dienste.txt -Append
# An Drucker
Get-Content dokument.txt | Out-Printer
# In GridView (GUI-Tabelle)
Get-Process | Out-GridView
# Ausgabe verwerfen
Get-Process | Out-Null
Out-GridView ist großartig für interaktive Daten-Exploration mit Filter- und Sortier-Funktionen!Modul 2.8: Daten exportieren und importieren
CSV-Format
# Prozesse in CSV exportieren
Get-Process | Export-Csv prozesse.csv -NoTypeInformation
# CSV importieren
$prozesse = Import-Csv prozesse.csv
# Mit Delimiter
Get-Service | Export-Csv dienste.csv -Delimiter ";" -NoTypeInformation
# Encoding festlegen
Export-Csv daten.csv -Encoding UTF8
JSON-Format
# In JSON konvertieren
Get-Service | Select-Object -First 5 | ConvertTo-Json
# In Datei speichern
Get-Process | Select-Object Name, Id, CPU | ConvertTo-Json | Out-File prozesse.json
# JSON importieren
$daten = Get-Content prozesse.json | ConvertFrom-Json
# Mit Tiefe (für verschachtelte Objekte)
$komplexesDatenObjekt | ConvertTo-Json -Depth 5
XML-Format
# Nach XML exportieren
Get-Process | Export-Clixml prozesse.xml
# XML importieren (mit vollständiger Objekt-Wiederherstellung!)
$prozesse = Import-Clixml prozesse.xml
# ConvertTo-Xml für XML-String
Get-Service | ConvertTo-Xml -As String
Export-Clixml / Import-Clixml bewahren die vollständigen PowerShell-Objekte mit allen Eigenschaften und Methoden!HTML-Format
# HTML-Bericht erstellen
Get-Process | ConvertTo-Html | Out-File bericht.html
# Mit Eigenschaften und Styling
Get-Service | Select-Object Name, Status, StartType |
ConvertTo-Html -Title "Dienste-Bericht" -PreContent "<h1>Systemdienste</h1>" |
Out-File dienste.html
# Im Browser öffnen
Invoke-Item dienste.html
Vergleich der Formate
| Format | Vorteile | Nachteile | Verwendung |
|---|---|---|---|
| CSV | Einfach, Excel-kompatibel | Nur flache Daten | Tabellen, Reports |
| JSON | Webstandard, lesbar | Keine Methodeninfo | APIs, Web-Anwendungen |
| XML (CliXml) | Vollständige Objekte | Größe, Komplexität | PowerShell-zu-PowerShell |
| HTML | Visuell, teilbar | Nur Ansicht, nicht importierbar | Berichte, Dokumentation |
Praktische Übungen
Übung 1: Pipeline-Grundlagen
Aufgabe:
- Zeige alle laufenden Dienste an
- Sortiere sie alphabetisch nach Namen
- Zeige nur die ersten 10
- Exportiere das Ergebnis in eine CSV-Datei
Lösung anzeigen
Get-Service |
Where-Object Status -eq 'Running' |
Sort-Object Name |
Select-Object -First 10 |
Export-Csv dienste_running.csv -NoTypeInformation
Übung 2: Objekte untersuchen
Aufgabe:
- Wähle einen beliebigen Prozess aus
- Untersuche seine Eigenschaften mit Get-Member
- Erstelle eine Ausgabe mit Name, ID und Arbeitsspeicher in MB (gerundet auf 2 Dezimalstellen)
- Sortiere nach Arbeitsspeicher absteigend
Lösung anzeigen
# Eigenschaften untersuchen
Get-Process | Select-Object -First 1 | Get-Member
# Formatierte Ausgabe
Get-Process |
Select-Object Name, Id,
@{N='MemoryMB'; E={[math]::Round($_.WorkingSet / 1MB, 2)}} |
Sort-Object MemoryMB -Descending
Übung 3: Komplexe Filterung
Aufgabe:
- Finde alle Dateien im Temp-Ordner, die größer als 10 MB sind
- Filtere nach .log und .tmp Dateien
- Sortiere nach Größe absteigend
- Zeige Name, Größe in MB und Änderungsdatum
Lösung anzeigen
Get-ChildItem $env:TEMP -Recurse -File -ErrorAction SilentlyContinue |
Where-Object {$_.Length -gt 10MB -and ($_.Extension -eq '.log' -or $_.Extension -eq '.tmp')} |
Sort-Object Length -Descending |
Select-Object Name,
@{N='SizeMB'; E={[math]::Round($_.Length / 1MB, 2)}},
LastWriteTime
Übung 4: Statistiken erstellen
Aufgabe:
- Berechne die Gesamtanzahl aller Prozesse
- Finde den Prozess mit der höchsten CPU-Auslastung
- Berechne den durchschnittlichen Arbeitsspeicher aller Prozesse
- Erstelle einen formatierten Bericht als HTML
Lösung anzeigen
# Anzahl
$anzahl = (Get-Process | Measure-Object).Count
# Höchste CPU
$topCPU = Get-Process | Sort-Object CPU -Descending | Select-Object -First 1
# Durchschnittlicher Speicher
$avgMemory = Get-Process | Measure-Object -Property WorkingSet -Average
# Bericht erstellen
$bericht = [PSCustomObject]@{
'Gesamte Prozesse' = $anzahl
'Top CPU Prozess' = $topCPU.Name
'Top CPU Wert' = [math]::Round($topCPU.CPU, 2)
'Durchschn. RAM (MB)' = [math]::Round($avgMemory.Average / 1MB, 2)
}
$bericht | ConvertTo-Html -Title "Prozess-Statistiken" | Out-File stats.html
Invoke-Item stats.html
Übung 5: Daten-Export und -Import
Aufgabe:
- Exportiere alle gestoppten Dienste in eine JSON-Datei
- Importiere die Daten wieder
- Zeige die Anzahl der gestoppten Dienste an
- Erstelle eine formatierte Tabelle mit den ersten 5
Lösung anzeigen
# Exportieren
Get-Service |
Where-Object Status -eq 'Stopped' |
Select-Object Name, DisplayName, Status |
ConvertTo-Json |
Out-File gestoppt.json
# Importieren
$dienste = Get-Content gestoppt.json | ConvertFrom-Json
# Anzahl
Write-Host "Anzahl gestoppter Dienste: $($dienste.Count)"
# Tabelle
$dienste | Select-Object -First 5 | Format-Table -AutoSize
Übung 6: Fortgeschrittene Pipeline
Aufgabe: Erstelle ein Skript, das:
- Alle Dateien im Downloads-Ordner findet
- Nach Dateityp (Extension) gruppiert
- Für jeden Dateityp die Anzahl und Gesamtgröße berechnet
- Das Ergebnis sortiert nach Gesamtgröße
- Als CSV exportiert
Lösung anzeigen
Get-ChildItem ~\Downloads -File |
Group-Object Extension |
Select-Object @{N='Dateityp'; E={$_.Name}},
@{N='Anzahl'; E={$_.Count}},
@{N='GesamtgrößeMB'; E={[math]::Round(($_.Group | Measure-Object -Property Length -Sum).Sum / 1MB, 2)}} |
Sort-Object GesamtgrößeMB -Descending |
Export-Csv downloads_statistik.csv -NoTypeInformation
# Ergebnis auch anzeigen
Import-Csv downloads_statistik.csv | Format-Table -AutoSize
Zusammenfassung
In diesem Kurs hast du gelernt:
✓ Wie die PowerShell-Pipeline funktioniert und warum sie objektorientiert ist ✓ Objekte mit Get-Member zu untersuchen ✓ Daten mit Where-Object zu filtern ✓ Eigenschaften mit Select-Object auszuwählen ✓ Ergebnisse mit Sort-Object zu sortieren ✓ Statistiken mit Measure-Object zu berechnen ✓ Ausgaben mit Format-Cmdlets zu formatieren ✓ Daten in verschiedenen Formaten zu exportieren und importieren
Wichtige Cmdlets aus Kurs 2
| Cmdlet | Zweck | Beispiel |
|---|---|---|
Get-Member |
Objekte untersuchen | Get-Member |
Where-Object |
Filtern | Where-Object Status -eq 'Running'
|
Select-Object |
Eigenschaften wählen | Select-Object Name, CPU
|
Sort-Object |
Sortieren | Sort-Object CPU -Descending
|
Measure-Object |
Statistiken | Measure-Object -Sum -Average
|
Format-Table |
Tabelle | Format-Table -AutoSize
|
Format-List |
Liste | Format-List *
|
Export-Csv |
CSV exportieren | Export-Csv daten.csv
|
ConvertTo-Json |
JSON erstellen | ConvertTo-Json
|
Out-GridView |
GUI-Tabelle | Out-GridView
|
Pipeline-Best-Practices
DO:
- Verwende die Pipeline für Datenverarbeitung
- Filtere so früh wie möglich (Where-Object am Anfang)
- Format-Cmdlets immer am Ende
- Verwende sinnvolle Variablennamen bei Zwischenspeicherung
- Nutze Select-Object, um nur benötigte Eigenschaften zu behalten
DON'T:
- Keine Format-Cmdlets in der Mitte der Pipeline
- Nicht unnötig viele Objekte durch die gesamte Pipeline schicken
- Nicht zu viele Pipe-Stufen ohne Zwischenvariablen (Lesbarkeit!)
- Keine Formatierung vor dem Export
Nächste Schritte
Im nächsten Kurs lernst du:
- Variablen richtig einsetzen
- Mit verschiedenen Datentypen arbeiten
- Arrays und Hashtables verwenden
- Datenstrukturen effektiv nutzen
Zusätzliche Ressourcen
Cheat Sheet - Pipeline
# Grundmuster
Get-Command | Where-Object | Select-Object | Sort-Object | Format-Table
# Objekte untersuchen
Get-Process | Get-Member
Get-Service | Get-Member -MemberType Property
# Filtern
Where-Object Status -eq 'Running'
Where-Object {$_.CPU -gt 10 -and $_.Name -like "chrome*"}
# Auswählen
Select-Object Name, CPU
Select-Object -First 10
Select-Object @{N='Custom'; E={$_.Property * 2}}
# Sortieren
Sort-Object Name
Sort-Object CPU -Descending
# Messen
Measure-Object
Measure-Object -Property Length -Sum -Average
# Formatieren
Format-Table -AutoSize
Format-List *
Out-GridView
# Exportieren
Export-Csv daten.csv -NoTypeInformation
ConvertTo-Json | Out-File daten.json
Export-Clixml daten.xml
Häufige Patterns
# Top-N Pattern
Get-Process | Sort-Object CPU -Descending | Select-Object -First 10
# Gruppierung
Get-ChildItem | Group-Object Extension | Select-Object Name, Count
# Eindeutige Werte
Get-Process | Select-Object ProcessName -Unique
# Zählen
(Get-Service | Where-Object Status -eq 'Running').Count
# Summe berechnen
(Get-ChildItem | Measure-Object -Property Length -Sum).Sum / 1GB
# Eigenschaften hinzufügen
Get-Process | Select-Object *, @{N='MemMB'; E={$_.WS/1MB}}
Übungsaufgaben für zuhause
- Erstelle einen Bericht über alle Dienste auf deinem System (Status, StartType, Anzahl pro Status)
- Finde die 20 größten Dateien auf deinem System und speichere sie als HTML-Bericht
- Analysiere deine Prozesse: Erstelle Statistiken über CPU, RAM und Anzahl nach Prozessname
- Erstelle ein Skript, das alle .txt-Dateien in einem Ordner findet, die älter als 30 Tage sind und deren Gesamtgröße berechnet
- Experimentiere mit Out-GridView: Lade Prozesse hinein und nutze die Filter-Funktionen
Debugging-Tipps
Wenn deine Pipeline nicht funktioniert:
# Schritt für Schritt testen
Get-Service # Funktioniert?
Get-Service | Where-Object Status -eq 'Running' # Funktioniert?
Get-Service | Where-Object Status -eq 'Running' | Sort-Object Name # Funktioniert?
# Objekt-Typ prüfen
Get-Service | Get-Member # Was ist der TypeName?
# Zwischenergebnisse speichern
$dienste = Get-Service | Where-Object Status -eq 'Running'
$dienste | Sort-Object Name
# Eigenschaften prüfen
Get-Process | Select-Object -First 1 | Format-List *
Leistungs-Tipps
| Langsam | Schnell | Grund |
|---|---|---|
Get-ChildItem -Recurse dann Where-Object |
Get-ChildItem -Recurse -Filter |
Filter auf Server-Seite |
ForEach-Object für einfache Filter |
Where-Object |
Optimiert für Filterung |
| Format-Table in Mitte der Pipeline | Format-Table am Ende | Formatierungsobjekte blockieren |
| Alle Eigenschaften durchschleifen | Select-Object früh nutzen | Weniger Daten = schneller |
Praktische Beispiele
# 1. Speicherverbrauch-Alarm
Get-Process |
Where-Object WorkingSet -gt 500MB |
Sort-Object WorkingSet -Descending |
Select-Object Name, @{N='RAM(GB)'; E={[math]::Round($_.WS/1GB, 2)}} |
Format-Table -AutoSize
# 2. Dienst-Überwachung
Get-Service |
Where-Object {$_.Status -eq 'Stopped' -and $_.StartType -eq 'Automatic'} |
Select-Object Name, DisplayName, Status |
Export-Csv gestoppte_auto_dienste.csv -NoTypeInformation
# 3. Festplatten-Analyse
Get-ChildItem C:\ -Recurse -File -ErrorAction SilentlyContinue |
Group-Object Extension |
Select-Object @{N='Typ'; E={if($_.Name){"$($_.Name)"}else{"Kein"}}},
@{N='Anzahl'; E={$_.Count}},
@{N='Größe(GB)'; E={[math]::Round(($_.Group | Measure-Object Length -Sum).Sum/1GB, 2)}} |
Sort-Object 'Größe(GB)' -Descending |
Out-GridView -Title "Dateityp-Analyse"
# 4. Prozess-Monitor für bestimmte Anwendung
while($true) {
Clear-Host
Get-Process chrome -ErrorAction SilentlyContinue |
Select-Object Name, Id, CPU,
@{N='RAM(MB)'; E={[math]::Round($_.WS/1MB, 2)}} |
Format-Table -AutoSize
Start-Sleep -Seconds 2
}
# 5. Event-Log Analyse
Get-EventLog -LogName System -EntryType Error -Newest 50 |
Group-Object Source |
Select-Object @{N='Fehlerquelle'; E={$_.Name}},
@{N='Anzahl'; E={$_.Count}} |
Sort-Object Anzahl -Descending |
Format-Table -AutoSize
# 6. Netzwerk-Verbindungen
Get-NetTCPConnection -State Established |
Select-Object LocalAddress, LocalPort, RemoteAddress, RemotePort, State,
@{N='Prozess'; E={(Get-Process -Id $_.OwningProcess).ProcessName}} |
Sort-Object Prozess |
Format-Table -AutoSize
# 7. Aufräum-Bericht
$ordner = "$env:TEMP"
$vorher = (Get-ChildItem $ordner -Recurse -File | Measure-Object Length -Sum).Sum
Get-ChildItem $ordner -Recurse -File -Filter "*.tmp" | Remove-Item -Force
$nachher = (Get-ChildItem $ordner -Recurse -File | Measure-Object Length -Sum).Sum
$gespart = [math]::Round(($vorher - $nachher) / 1MB, 2)
Write-Host "Gespart: $gespart MB"
Interaktive Übung: Out-GridView
Probiere diese interaktiven Beispiele:
# 1. Prozesse filtern und auswählen
Get-Process |
Select-Object Name, Id, CPU,
@{N='RAM(MB)'; E={[math]::Round($_.WS/1MB)}} |
Out-GridView -Title "Wähle Prozesse zum Beenden" -PassThru |
Stop-Process -WhatIf # -WhatIf für Simulation
# 2. Dienste interaktiv starten
Get-Service |
Where-Object Status -eq 'Stopped' |
Out-GridView -Title "Wähle Dienste zum Starten" -PassThru |
Start-Service -WhatIf
# 3. Dateien zum Löschen auswählen
Get-ChildItem C:\Temp -Recurse -File |
Where-Object Length -gt 10MB |
Select-Object Name,
@{N='Größe(MB)'; E={[math]::Round($_.Length/1MB, 2)}},
LastWriteTime, FullName |
Out-GridView -Title "Große Dateien - Zum Löschen auswählen" -PassThru |
Remove-Item -WhatIf
-PassThru bei Out-GridView ermöglicht die Auswahl von Zeilen, die dann weitergeleitet werden!Erweiterte Pipeline-Techniken
# ForEach-Object für Transformationen
Get-ChildItem *.txt | ForEach-Object {
$neuerName = $_.Name -replace "alt", "neu"
Rename-Item $_.FullName -NewName $neuerName -WhatIf
}
# Tee-Object - Pipeline aufteilen
Get-Process |
Tee-Object -FilePath prozesse.csv |
Where-Object CPU -gt 10 |
Format-Table
# Group-Object mit Berechnungen
Get-Process |
Group-Object ProcessName |
Select-Object Name,
Count,
@{N='TotalRAM(MB)'; E={[math]::Round(($_.Group | Measure-Object WS -Sum).Sum/1MB)}}
# Compare-Object - Unterschiede finden
$vorher = Get-Process | Select-Object Name
Start-Process notepad
Start-Sleep 2
$nachher = Get-Process | Select-Object Name
Compare-Object $vorher $nachher -Property Name
Fehler-Vermeidung
Häufige Fehler und Lösungen:
# FEHLER: Format-Table in der Mitte
Get-Process | Format-Table | Where-Object CPU -gt 10 # ❌ Funktioniert nicht!
# RICHTIG:
Get-Process | Where-Object CPU -gt 10 | Format-Table # ✓
# FEHLER: Falsche Eigenschaft
Get-Process | Where-Object Memory -gt 100MB # ❌ Eigenschaft existiert nicht
# RICHTIG: Erst mit Get-Member prüfen
Get-Process | Get-Member
Get-Process | Where-Object WorkingSet -gt 100MB # ✓
# FEHLER: Vergleich ohne Operator
Get-Service | Where-Object Status 'Running' # ❌ Fehlt -eq
# RICHTIG:
Get-Service | Where-Object Status -eq 'Running' # ✓
# FEHLER: Methode statt Eigenschaft
Get-Date | Select-Object AddDays(7) # ❌ Methoden müssen aufgerufen werden
# RICHTIG:
(Get-Date).AddDays(7) # ✓