Powershell - Variablen und Datentypen
Kursübersicht
[Bearbeiten | Quelltext bearbeiten]Voraussetzungen: Kurs 1 und 2 abgeschlossen
Lernziele:
- Du verstehst, wie Variablen in PowerShell funktionieren
- Du arbeitest mit verschiedenen Datentypen
- Du verwendest Arrays effektiv
- Du nutzt Hashtables und PSCustomObject
- Du beherrschst Typkonvertierung und Scopes
Modul 3.1: Variablen-Grundlagen
[Bearbeiten | Quelltext bearbeiten]Variablen erstellen und verwenden
[Bearbeiten | Quelltext bearbeiten]In PowerShell beginnen Variablen immer mit dem $-Zeichen:
# Einfache Zuweisung
$name = "Max Mustermann"
$alter = 30
$istAktiv = $true
# Variable ausgeben
Write-Host $name
Write-Host "Name: $name, Alter: $alter"
# Variable in Befehlen verwenden
Get-Process -Name $prozessName
Set-Location $pfad
Variablen-Namensregeln
[Bearbeiten | Quelltext bearbeiten]| Regel | Beispiel | Gültig? |
|---|---|---|
| Beginnt mit $ | $variable |
✓ |
| Buchstaben, Zahlen, Unterstrich | $meine_variable_1 |
✓ |
| Camel Case (empfohlen) | $meineVariable |
✓ |
| Leerzeichen mit {} | ${Meine Variable} |
✓ (nicht empfohlen) |
| Sonderzeichen | $meine-variable |
✗ |
| Beginnt mit Zahl | $1variable |
✗ |
$benutzerName statt $bn oder $xVariablen anzeigen und löschen
[Bearbeiten | Quelltext bearbeiten]# Alle Variablen anzeigen
Get-Variable
# Bestimmte Variable
Get-Variable name
# Variable existiert?
Test-Path variable:meineVariable
# Variable löschen
Remove-Variable name
# Mehrere Variablen löschen
Remove-Variable name, alter, istAktiv
# Alle benutzerdefinierten Variablen löschen (Vorsicht!)
Get-Variable | Where-Object {$_.Options -notmatch "Constant|ReadOnly"} | Remove-Variable -ErrorAction SilentlyContinue
String-Interpolation
[Bearbeiten | Quelltext bearbeiten]$vorname = "Anna"
$nachname = "Schmidt"
$alter = 28
# Doppelte Anführungszeichen: Variablen werden ersetzt
Write-Host "Name: $vorname $nachname, Alter: $alter"
# Einfache Anführungszeichen: Keine Ersetzung
Write-Host 'Name: $vorname $nachname' # Gibt wörtlich aus
# Expressions in Strings
Write-Host "In 5 Jahren: $($alter + 5) Jahre alt"
Write-Host "Großbuchstaben: $($vorname.ToUpper())"
# Here-Strings für mehrzeiligen Text
$text = @"
Hallo $vorname,
du bist $alter Jahre alt.
Vielen Dank!
"@
Modul 3.2: Datentypen
[Bearbeiten | Quelltext bearbeiten]Grundlegende Datentypen
[Bearbeiten | Quelltext bearbeiten]PowerShell arbeitet mit .NET-Datentypen. Die wichtigsten sind:
| Datentyp | Beschreibung | Beispiel | .NET-Typ |
|---|---|---|---|
| String | Zeichenkette | $text = "Hallo" |
System.String |
| Int | Ganzzahl (32-bit) | $zahl = 42 |
System.Int32 |
| Long | Ganzzahl (64-bit) | $gross = 9999999999 |
System.Int64 |
| Double | Gleitkommazahl | $preis = 19.99 |
System.Double |
| Boolean | Wahrheitswert | $aktiv = $true |
System.Boolean |
| DateTime | Datum/Zeit | $datum = Get-Date |
System.DateTime |
| Array | Liste von Elementen | $liste = @(1,2,3) |
System.Array |
| Hashtable | Key-Value-Paare | $hash = @{} |
System.Collections.Hashtable |
Datentyp ermitteln
[Bearbeiten | Quelltext bearbeiten]# GetType() Methode
$name = "Anna"
$name.GetType()
# Ausgabe:
# IsPublic IsSerial Name BaseType
# -------- -------- ---- --------
# True True String System.Object
# Kurzform: Nur TypeName
$name.GetType().Name # String
$name.GetType().FullName # System.String
# Mehrere Variablen prüfen
$zahl = 42
$zahl.GetType().Name # Int32
$datum = Get-Date
$datum.GetType().Name # DateTime
Typdeklaration (Type Casting)
[Bearbeiten | Quelltext bearbeiten]Du kannst den Datentyp explizit festlegen:
# Explizite Typzuweisung
[string]$name = "Anna"
[int]$alter = 30
[double]$preis = 19.99
[bool]$aktiv = $true
[datetime]$datum = "2025-01-15"
# Typ erzwingen
[int]$zahl = "42" # String wird zu Int konvertiert
[string]$text = 123 # Zahl wird zu String
# Array mit Typbeschränkung
[int[]]$zahlen = 1,2,3,4,5
$zahlen += "6" # Wird automatisch zu Int konvertiert
$zahlen += "text" # Fehler! Kann nicht konvertiert werden
Typkonvertierung
[Bearbeiten | Quelltext bearbeiten]# String zu Zahl
$text = "42"
$zahl = [int]$text
$zahl = $text -as [int] # Alternative, gibt $null bei Fehler
# Zahl zu String
$zahl = 42
$text = [string]$zahl
$text = "$zahl" # Einfachste Methode
# String zu DateTime
$dateString = "2025-11-05"
$datum = [datetime]$dateString
$datum = Get-Date $dateString
# Boolean Konvertierung
[bool]1 # True
[bool]0 # False
[bool]"text" # True (nicht-leerer String)
[bool]"" # False (leerer String)
# Sichere Konvertierung mit -as
$wert = "keine zahl" -as [int]
if ($wert -eq $null) {
Write-Host "Konvertierung fehlgeschlagen"
}
Zahlen und Operatoren
[Bearbeiten | Quelltext bearbeiten]# Mathematische Operatoren
$a = 10
$b = 3
$summe = $a + $b # 13
$differenz = $a - $b # 7
$produkt = $a * $b # 30
$quotient = $a / $b # 3.333...
$rest = $a % $b # 1 (Modulo)
# Kurzformen
$a += 5 # $a = $a + 5
$a -= 2 # $a = $a - 2
$a *= 2 # $a = $a * 2
$a /= 3 # $a = $a / 3
$a++ # $a = $a + 1
$a-- # $a = $a - 1
# Potenzierung (ab PowerShell 7)
2 -pow 8 # 256 (PowerShell 7+)
[math]::Pow(2, 8) # 256 (alle Versionen)
# Mathematische Funktionen
[math]::Round(3.7) # 4
[math]::Floor(3.7) # 3
[math]::Ceiling(3.2) # 4
[math]::Sqrt(16) # 4
[math]::Abs(-5) # 5
Größeneinheiten
[Bearbeiten | Quelltext bearbeiten]PowerShell unterstützt praktische Größeneinheiten:
# Byte-Größen
1KB # 1024 Bytes
1MB # 1048576 Bytes
1GB # 1073741824 Bytes
1TB # 1099511627776 Bytes
1PB # 1125899906842624 Bytes
# Praktische Verwendung
$dateiGroesse = 52428800 # Bytes
$groesseInMB = $dateiGroesse / 1MB
Write-Host "$groesseInMB MB" # 50 MB
# Direkte Verwendung
if ((Get-Item datei.zip).Length -gt 100MB) {
Write-Host "Datei ist größer als 100 MB"
}
Modul 3.3: Arrays
[Bearbeiten | Quelltext bearbeiten]Arrays erstellen
[Bearbeiten | Quelltext bearbeiten]# Leeres Array
$leer = @()
# Array mit Werten
$zahlen = @(1, 2, 3, 4, 5)
$namen = @("Anna", "Bob", "Clara")
# Ohne @() - Komma-getrennt
$farben = "Rot", "Grün", "Blau"
# Range-Operator
$bereich = 1..10 # Array von 1 bis 10
$buchstaben = 'a'..'z' # a bis z (PowerShell 6+)
# Gemischte Typen
$gemischt = @(1, "Text", $true, (Get-Date))
# Array mit einem Element (braucht @())
$einzeln = @(42) # Array mit 1 Element
$keinArray = 42 # Keine Array, nur Zahl
Auf Array-Elemente zugreifen
[Bearbeiten | Quelltext bearbeiten]$namen = @("Anna", "Bob", "Clara", "David", "Eva")
# Index beginnt bei 0
$namen[0] # Anna (erstes Element)
$namen[2] # Clara
$namen[-1] # Eva (letztes Element)
$namen[-2] # David (vorletztes)
# Mehrere Elemente
$namen[0,2,4] # Anna, Clara, Eva
$namen[1..3] # Bob, Clara, David (Index 1 bis 3)
# Anzahl der Elemente
$namen.Count # 5
$namen.Length # 5 (identisch mit Count)
Array-Operationen
[Bearbeiten | Quelltext bearbeiten]$zahlen = @(1, 2, 3)
# Element hinzufügen
$zahlen += 4 # @(1, 2, 3, 4)
$zahlen += @(5, 6) # @(1, 2, 3, 4, 5, 6)
# Arrays kombinieren
$array1 = @(1, 2, 3)
$array2 = @(4, 5, 6)
$kombiniert = $array1 + $array2
# Element ändern
$namen = @("Anna", "Bob", "Clara")
$namen[1] = "Barbara" # @("Anna", "Barbara", "Clara")
# Element "entfernen" (neu erstellen ohne Element)
$namen = $namen | Where-Object {$_ -ne "Anna"}
$namen = $namen -ne "Anna" # Kurzform
# Array leeren
$namen = @()
Array-Methoden
[Bearbeiten | Quelltext bearbeiten]$zahlen = @(5, 2, 8, 1, 9, 3)
# Sortieren
$sortiert = $zahlen | Sort-Object
[array]::Sort($zahlen) # In-Place Sortierung
# Umkehren
$umgekehrt = $zahlen | Sort-Object -Descending
[array]::Reverse($zahlen) # In-Place
# Enthält Element?
$zahlen -contains 8 # $true
$zahlen -contains 99 # $false
# Index eines Elements
[array]::IndexOf($zahlen, 8) # Gibt Position zurück
# Elemente durchlaufen
foreach ($zahl in $zahlen) {
Write-Host $zahl
}
# ForEach-Object in Pipeline
$zahlen | ForEach-Object {
$_ * 2 # Jede Zahl verdoppeln
}
ArrayList - Flexiblere Alternative
[Bearbeiten | Quelltext bearbeiten]Für häufige Änderungen ist ArrayList besser geeignet:
# ArrayList erstellen
$liste = [System.Collections.ArrayList]@()
# Elemente hinzufügen (schneller als Array +=)
$liste.Add("Anna") | Out-Null # | Out-Null unterdrückt Index-Ausgabe
$liste.Add("Bob") | Out-Null
# Mehrere auf einmal
$liste.AddRange(@("Clara", "David"))
# Element entfernen
$liste.Remove("Bob") # Nach Wert
$liste.RemoveAt(0) # Nach Index
# Eigenschaften
$liste.Count
$liste.Contains("Anna")
Modul 3.4: Hashtables
[Bearbeiten | Quelltext bearbeiten]Hashtables erstellen
[Bearbeiten | Quelltext bearbeiten]Hashtables speichern Key-Value-Paare (wie ein Wörterbuch):
# Leere Hashtable
$leer = @{}
# Hashtable mit Daten
$person = @{
Name = "Anna Schmidt"
Alter = 28
Stadt = "Wien"
Beruf = "Entwicklerin"
}
# Mehrzeilig (übersichtlicher)
$server = @{
Hostname = "SRV01"
IP = "192.168.1.100"
OS = "Windows Server 2022"
RAM_GB = 32
}
Auf Werte zugreifen
[Bearbeiten | Quelltext bearbeiten]# Punkt-Notation
$person.Name # "Anna Schmidt"
$person.Alter # 28
# Klammer-Notation
$person["Name"] # "Anna Schmidt"
$person['Alter'] # 28
# Vorteil Klammer-Notation: Variablen als Key
$key = "Stadt"
$person[$key] # "Wien"
# Key mit Leerzeichen
$daten = @{
"Erste Name" = "Anna"
"Letzte Name" = "Schmidt"
}
$daten["Erste Name"] # Mit Klammer-Notation
Hashtable-Operationen
[Bearbeiten | Quelltext bearbeiten]$person = @{
Name = "Anna"
Alter = 28
}
# Wert hinzufügen/ändern
$person.Stadt = "Wien" # Hinzufügen
$person["Beruf"] = "Entwicklerin" # Hinzufügen
$person.Alter = 29 # Ändern
# Wert entfernen
$person.Remove("Stadt")
# Existiert Key?
$person.ContainsKey("Name") # $true
$person.ContainsKey("Telefon") # $false
# Existiert Wert?
$person.ContainsValue("Anna") # $true
# Alle Keys
$person.Keys
# Alle Values
$person.Values
# Anzahl Einträge
$person.Count
# Hashtable leeren
$person.Clear()
Durch Hashtables iterieren
[Bearbeiten | Quelltext bearbeiten]$person = @{
Name = "Anna"
Alter = 28
Stadt = "Wien"
}
# Mit foreach
foreach ($key in $person.Keys) {
Write-Host "$key : $($person[$key])"
}
# Mit GetEnumerator()
$person.GetEnumerator() | ForEach-Object {
Write-Host "$($_.Key) = $($_.Value)"
}
# Sortiert nach Key
$person.GetEnumerator() | Sort-Object Key | ForEach-Object {
Write-Host "$($_.Key): $($_.Value)"
}
Ordered Hashtables
[Bearbeiten | Quelltext bearbeiten]Normale Hashtables haben keine Reihenfolge. Für geordnete Hashtables:
# Geordnete Hashtable
$person = [ordered]@{
Name = "Anna"
Alter = 28
Stadt = "Wien"
Beruf = "Entwicklerin"
}
# Behält Einfüge-Reihenfolge
$person.Keys # Name, Alter, Stadt, Beruf (in dieser Reihenfolge)
[ordered] wenn die Reihenfolge wichtig ist, z.B. für Konfigurationsdateien.Modul 3.5: PSCustomObject
[Bearbeiten | Quelltext bearbeiten]Was ist PSCustomObject?
[Bearbeiten | Quelltext bearbeiten]PSCustomObject ist eine moderne, flexible Art, strukturierte Daten zu erstellen:
# PSCustomObject erstellen
$person = [PSCustomObject]@{
Name = "Anna Schmidt"
Alter = 28
Stadt = "Wien"
Beruf = "Entwicklerin"
}
# Ausgabe
$person
# Ausgabe:
# Name Alter Stadt Beruf
# ---- ----- ----- -----
# Anna Schmidt 28 Wien Entwicklerin
PSCustomObject vs. Hashtable
[Bearbeiten | Quelltext bearbeiten]| Feature | Hashtable | PSCustomObject |
|---|---|---|
| Reihenfolge | Nein (außer [ordered]) | Ja |
| Tabellarische Ausgabe | Nein | Ja |
| Pipeline-freundlich | Bedingt | Sehr gut |
| Eigenschaften hinzufügen | Einfach | Mit Add-Member |
| Verwendung | Konfiguration, Lookup | Daten-Objekte, Export |
PSCustomObject erstellen und verwenden
[Bearbeiten | Quelltext bearbeiten]# Einzelnes Objekt
$benutzer = [PSCustomObject]@{
ID = 1
Name = "Anna"
Email = "anna@example.com"
Aktiv = $true
}
# Array von Objekten
$benutzer = @(
[PSCustomObject]@{
ID = 1
Name = "Anna"
Abteilung = "IT"
},
[PSCustomObject]@{
ID = 2
Name = "Bob"
Abteilung = "HR"
},
[PSCustomObject]@{
ID = 3
Name = "Clara"
Abteilung = "IT"
}
)
# Pipeline-Verwendung
$benutzer | Where-Object Abteilung -eq "IT"
$benutzer | Sort-Object Name
$benutzer | Export-Csv benutzer.csv -NoTypeInformation
Eigenschaften zu PSCustomObject hinzufügen
[Bearbeiten | Quelltext bearbeiten]$person = [PSCustomObject]@{
Name = "Anna"
Alter = 28
}
# Eigenschaft hinzufügen
$person | Add-Member -MemberType NoteProperty -Name "Stadt" -Value "Wien"
# Mehrere Eigenschaften
$person | Add-Member -NotePropertyMembers @{
Beruf = "Entwicklerin"
Gehalt = 50000
}
# Methode hinzufügen
$person | Add-Member -MemberType ScriptMethod -Name "Greeting" -Value {
return "Hallo, ich bin $($this.Name)"
}
$person.Greeting() # "Hallo, ich bin Anna"
Objekte dynamisch erstellen
[Bearbeiten | Quelltext bearbeiten]# Aus Hashtable
$daten = @{Name="Anna"; Alter=28}
$objekt = New-Object PSObject -Property $daten
# Mit Select-Object
$prozesse = Get-Process | Select-Object Name, Id,
@{N='MemoryMB'; E={[math]::Round($_.WS/1MB,2)}}
# Jedes Element ist ein PSCustomObject!
$prozesse[0].GetType().Name # PSCustomObject
Modul 3.6: Variable Scopes
[Bearbeiten | Quelltext bearbeiten]Was sind Scopes?
[Bearbeiten | Quelltext bearbeiten]Scopes bestimmen die Sichtbarkeit von Variablen. PowerShell hat vier Haupt-Scopes:
| Scope | Beschreibung | Lebensdauer |
|---|---|---|
| Global | Überall sichtbar | Gesamte Sitzung |
| Script | Im ganzen Skript | Skript-Ausführung |
| Local | Aktueller Bereich | Aktueller Block |
| Private | Nur aktueller Bereich, nicht vererbbar | Aktueller Block |
Scope-Beispiele
[Bearbeiten | Quelltext bearbeiten]# Global Scope
$global:meineVariable = "Global"
# Script Scope (in .ps1 Datei)
$script:meineVariable = "Script"
# Local Scope (Standard)
$meineVariable = "Local"
# Private Scope
$private:meineVariable = "Private"
# Scope anzeigen
Get-Variable meineVariable -Scope Global
Get-Variable meineVariable -Scope Local
Scope in Funktionen
[Bearbeiten | Quelltext bearbeiten]# Variable außerhalb der Funktion
$zahl = 100
function Test-Scope {
# Lokale Variable (nur in Funktion)
$zahl = 50
Write-Host "In Funktion: $zahl" # 50
# Global Variable ändern
$global:zahl = 25
}
Test-Scope
Write-Host "Außerhalb: $zahl" # 25 (wurde durch $global: geändert)
# Ohne $global:
$zahl = 100
function Test-Local {
$zahl = 50 # Lokale Kopie
Write-Host "In Funktion: $zahl"
}
Test-Local
Write-Host "Außerhalb: $zahl" # 100 (unverändert)
Parent-Child-Scope
[Bearbeiten | Quelltext bearbeiten]$parent = "Eltern-Wert"
& {
# Kind-Scope (& erstellt neuen Scope)
Write-Host "Kind liest: $parent" # Funktioniert! (Lesen)
$parent = "Kind-Wert" # Erstellt lokale Kopie
Write-Host "Kind ändert: $parent" # Kind-Wert
}
Write-Host "Eltern nach Kind: $parent" # Eltern-Wert (unverändert)
Praktische Übungen
[Bearbeiten | Quelltext bearbeiten]Übung 1: Variablen und Strings
[Bearbeiten | Quelltext bearbeiten]Aufgabe:
- Erstelle Variablen für Vorname, Nachname und Alter
- Kombiniere sie zu einem vollständigen Satz
- Verwende String-Interpolation
- Berechne, wie alt die Person in 10 Jahren sein wird
Lösung anzeigen
$vorname = "Anna"
$nachname = "Schmidt"
$alter = 28
# String-Interpolation
$vollstaendig = "Mein Name ist $vorname $nachname und ich bin $alter Jahre alt."
Write-Host $vollstaendig
# Berechnung
$in10Jahren = $alter + 10
Write-Host "In 10 Jahren bin ich $in10Jahren Jahre alt."
# Alternative mit Expression
Write-Host "In 10 Jahren bin ich $($alter + 10) Jahre alt."
Übung 2: Arrays verwalten
[Bearbeiten | Quelltext bearbeiten]Aufgabe:
- Erstelle ein Array mit 5 Städtenamen
- Gib die erste und letzte Stadt aus
- Füge zwei weitere Städte hinzu
- Sortiere das Array alphabetisch
- Zeige die Anzahl der Städte an
Lösung anzeigen
# Array erstellen
$staedte = @("Wien", "Berlin", "Paris", "London", "Madrid")
# Erste und letzte
Write-Host "Erste Stadt: $($staedte[0])"
Write-Host "Letzte Stadt: $($staedte[-1])"
# Hinzufügen
$staedte += "Rom"
$staedte += "Amsterdam"
# Sortieren
$staedte = $staedte | Sort-Object
# Ausgabe
Write-Host "Anzahl Städte: $($staedte.Count)"
$staedte | ForEach-Object { Write-Host "- $_" }
Übung 3: Hashtable für Benutzer
[Bearbeiten | Quelltext bearbeiten]Aufgabe:
- Erstelle eine Hashtable für einen Benutzer (Name, Email, Abteilung, Aktiv)
- Füge ein weiteres Feld "Telefon" hinzu
- Gib alle Keys und Values aus
- Prüfe, ob der Key "Email" existiert
- Ändere den Wert von "Aktiv"
Lösung anzeigen
# Hashtable erstellen
$benutzer = @{
Name = "Max Mustermann"
Email = "max@example.com"
Abteilung = "IT"
Aktiv = $true
}
# Feld hinzufügen
$benutzer.Telefon = "+43 123 456789"
# Keys und Values ausgeben
Write-Host "=== Benutzer-Daten ==="
foreach ($key in $benutzer.Keys) {
Write-Host "$key : $($benutzer[$key])"
}
# Key existiert?
if ($benutzer.ContainsKey("Email")) {
Write-Host "`nEmail gefunden: $($benutzer.Email)"
}
# Wert ändern
$benutzer.Aktiv = $false
Write-Host "Aktiv-Status geändert auf: $($benutzer.Aktiv)"
Übung 4: PSCustomObject-Array
[Bearbeiten | Quelltext bearbeiten]Aufgabe:
- Erstelle ein Array mit 3 PSCustomObjects für Produkte (Name, Preis, Lagerbestand)
- Filtere Produkte mit Preis > 50
- Sortiere nach Preis absteigend
- Exportiere in CSV
- Berechne den Gesamtwert aller Produkte (Preis * Lagerbestand)
Lösung anzeigen
# Produkte erstellen
$produkte = @(
[PSCustomObject]@{Name="Laptop"; Preis=899; Lagerbestand=15},
[PSCustomObject]@{Name="Maus"; Preis=25; Lagerbestand=50},
[PSCustomObject]@{Name="Tastatur"; Preis=75; Lagerbestand=30},
[PSCustomObject]@{Name="Monitor"; Preis=299; Lagerbestand=20}
)
# Filtern
$teuer = $produkte | Where-Object Preis -gt 50
Write-Host "=== Produkte über 50 EUR ==="
$teuer | Format-Table
# Sortieren
$sortiert = $produkte | Sort-Object Preis -Descending
Write-Host "`n=== Sortiert nach Preis ==="
$sortiert | Format-Table
# Exportieren
$produkte | Export-Csv produkte.csv -NoTypeInformation
Write-Host "`nProdukte nach produkte.csv exportiert"
# Gesamtwert berechnen
$gesamtwert = ($produkte | ForEach-Object {$_.Preis * $_.Lagerbestand} | Measure-Object -Sum).Sum
Write-Host "`nGesamtwert aller Produkte: $gesamtwert EUR"
Übung 5: Typkonvertierung
[Bearbeiten | Quelltext bearbeiten]Aufgabe:
- Erstelle einen String mit einer Zahl
- Konvertiere ihn zu Int und verdopple ihn
- Erstelle ein Datum aus einem String "2025-12-24"
- Berechne, wie viele Tage bis zu diesem Datum sind
- Konvertiere eine Dateigröße von Bytes in MB
Lösung anzeigen
# String zu Int
$zahlString = "42"
$zahl = [int]$zahlString
$verdoppelt = $zahl * 2
Write-Host "Verdoppelt: $verdoppelt"
# String zu DateTime
$datumString = "2025-12-24"
$datum = [datetime]$datumString
# Tage berechnen
$heute = Get-Date
$differenz = ($datum - $heute).Days
Write-Host "`nTage bis Weihnachten 2025: $differenz"
# Bytes zu MB
$dateiGroesse = 157286400 # Bytes
$groesseInMB = [math]::Round($dateiGroesse / 1MB, 2)
Write-Host "Dateigröße: $groesseInMB MB"
# Alternative mit PowerShell-Einheiten
$groesseInMB2 = $dateiGroesse / 1MB
Write-Host "Alternative: $groesseInMB2 MB"
Übung 6: Komplexe Datenstruktur
[Bearbeiten | Quelltext bearbeiten]Aufgabe: Erstelle eine verschachtelte Datenstruktur für eine Firma:
- Erstelle eine Hashtable "Firma" mit Name und Abteilungen
- Jede Abteilung ist ein Array von PSCustomObjects (Mitarbeiter)
- Jeder Mitarbeiter hat Name, Position, Gehalt
- Gib alle IT-Mitarbeiter aus
- Berechne das durchschnittliche Gehalt pro Abteilung
Lösung anzeigen
# Firma-Struktur
$firma = @{
Name = "Tech Solutions GmbH"
Abteilungen = @{
IT = @(
[PSCustomObject]@{Name="Anna Schmidt"; Position="Developer"; Gehalt=55000}
[PSCustomObject]@{Name="Bob Müller"; Position="Admin"; Gehalt=48000}
[PSCustomObject]@{Name="Clara Weber"; Position="DevOps"; Gehalt=52000}
)
HR = @(
[PSCustomObject]@{Name="David Klein"; Position="Manager"; Gehalt=60000}
[PSCustomObject]@{Name="Eva Lang"; Position="Recruiter"; Gehalt=45000}
)
Sales = @(
[PSCustomObject]@{Name="Frank Gross"; Position="Sales Manager"; Gehalt=65000}
[PSCustomObject]@{Name="Gina Kurz"; Position="Sales Rep"; Gehalt=42000}
)
}
}
# IT-Mitarbeiter ausgeben
Write-Host "=== IT-Abteilung ==="
$firma.Abteilungen.IT | Format-Table
# Durchschnittsgehalt pro Abteilung
Write-Host "`n=== Durchschnittsgehalt pro Abteilung ==="
foreach ($abteilung in $firma.Abteilungen.Keys) {
$mitarbeiter = $firma.Abteilungen[$abteilung]
$durchschnitt = ($mitarbeiter | Measure-Object -Property Gehalt -Average).Average
Write-Host "$abteilung : $([math]::Round($durchschnitt, 2)) EUR"
}
# Gesamtanzahl Mitarbeiter
$gesamt = 0
foreach ($abteilung in $firma.Abteilungen.Keys) {
$gesamt += $firma.Abteilungen[$abteilung].Count
}
Write-Host "`nGesamtanzahl Mitarbeiter: $gesamt"
Zusammenfassung
[Bearbeiten | Quelltext bearbeiten]In diesem Kurs hast du gelernt:
✓ Wie du Variablen erstellst und verwendest ✓ Mit verschiedenen Datentypen zu arbeiten (String, Int, DateTime, etc.) ✓ Arrays zu erstellen und zu manipulieren ✓ Hashtables für Key-Value-Paare zu nutzen ✓ PSCustomObject für strukturierte Daten zu verwenden ✓ Typkonvertierung durchzuführen ✓ Variable Scopes zu verstehen
Wichtige Konzepte aus Kurs 3
[Bearbeiten | Quelltext bearbeiten]| Konzept | Syntax | Verwendung |
|---|---|---|
| Variable | $name = "Wert" |
Daten speichern |
| Array | @(1,2,3) |
Liste von Elementen |
| Hashtable | @{Key="Value"} |
Key-Value-Paare |
| PSCustomObject | [PSCustomObject]@{} |
Strukturierte Objekte |
| Typkonvertierung | [int]$string |
Typ ändern |
| String-Interpolation | "Text $variable" |
Variablen in Strings |
| Scope | $global:variable |
Sichtbarkeit steuern |
Best Practices
[Bearbeiten | Quelltext bearbeiten]DO:
- Verwende aussagekräftige Variablennamen (
$benutzerNamestatt$x) - Nutze PSCustomObject für strukturierte Daten, die exportiert werden sollen
- Verwende [ordered] bei Hashtables, wenn Reihenfolge wichtig ist
- Deklariere Typen explizit, wenn wichtig:
[int]$zahl - Verwende Arrays für einfache Listen, ArrayList für häufige Änderungen
DON'T:
- Keine zu kurzen, kryptischen Namen
- Nicht unnötig globale Variablen verwenden
- Nicht Arrays mit += in Schleifen (performance-Problem)
- Keine Leerzeichen in Variablennamen ohne geschweifte Klammern
- Nicht auf Typkonvertierung verlassen ohne Fehlerbehandlung
Cheat Sheet - Datentypen
[Bearbeiten | Quelltext bearbeiten]# VARIABLEN
$text = "Hallo" # String
$zahl = 42 # Int32
$preis = 19.99 # Double
$aktiv = $true # Boolean
$datum = Get-Date # DateTime
# TYP PRÜFEN
$text.GetType().Name
# TYP KONVERTIEREN
[int]"42" # String zu Int
[string]123 # Zahl zu String
[datetime]"2025-01-15" # String zu DateTime
# ARRAYS
$array = @(1, 2, 3)
$array[0] # Erstes Element
$array[-1] # Letztes Element
$array += 4 # Hinzufügen
$array.Count # Anzahl
# HASHTABLES
$hash = @{Key="Value"}
$hash.Key # Zugriff mit Punkt
$hash["Key"] # Zugriff mit Klammer
$hash.NewKey = "NewValue" # Hinzufügen
$hash.ContainsKey("Key") # Prüfen
# PSCUSTOMOBJECT
$obj = [PSCustomObject]@{
Name = "Anna"
Alter = 28
}
$obj | Export-Csv daten.csv
# MATHEMATIK
10 + 5 # Addition
10 * 2 # Multiplikation
10 / 3 # Division
10 % 3 # Modulo
[math]::Round(3.7) # Runden
[math]::Sqrt(16) # Wurzel
# GRÖSSEN
1KB, 1MB, 1GB, 1TB, 1PB
Häufige Muster
[Bearbeiten | Quelltext bearbeiten]# Array von Objekten erstellen
$benutzer = @(
[PSCustomObject]@{Name="Anna"; Alter=28},
[PSCustomObject]@{Name="Bob"; Alter=35}
)
# Hashtable iterieren
foreach ($key in $hash.Keys) {
Write-Host "$key = $($hash[$key])"
}
# Array filtern und transformieren
$zahlen = 1..10
$gerade = $zahlen | Where-Object {$_ % 2 -eq 0}
$verdoppelt = $zahlen | ForEach-Object {$_ * 2}
# Berechnete Eigenschaft
$prozesse | Select-Object Name,
@{N='MemMB'; E={[math]::Round($_.WS/1MB,2)}}
# Daten gruppieren
$prozesse | Group-Object ProcessName |
Select-Object Name, Count
# Hashtable zu PSCustomObject
$hash = @{Name="Anna"; Alter=28}
$obj = [PSCustomObject]$hash
# Sichere Typkonvertierung
$wert = "text" -as [int]
if ($null -eq $wert) {
Write-Host "Konvertierung fehlgeschlagen"
}
Nächste Schritte
[Bearbeiten | Quelltext bearbeiten]Im nächsten Kurs lernst du:
- If-Else und Switch für Entscheidungen
- Verschiedene Schleifentypen (For, ForEach, While)
- Break und Continue verwenden
- Vergleichsoperatoren und logische Operatoren
- Komplexe Programmlogik erstellen
Zusätzliche Ressourcen
[Bearbeiten | Quelltext bearbeiten]Praktische Beispiele
[Bearbeiten | Quelltext bearbeiten]# 1. Inventar-System
$inventar = @(
[PSCustomObject]@{Artikel="Laptop"; Anzahl=15; Preis=899},
[PSCustomObject]@{Artikel="Maus"; Anzahl=50; Preis=25},
[PSCustomObject]@{Artikel="Tastatur"; Anzahl=30; Preis=75}
)
$gesamtwert = ($inventar | ForEach-Object {$_.Anzahl * $_.Preis} |
Measure-Object -Sum).Sum
Write-Host "Gesamtwert Inventar: $gesamtwert EUR"
# 2. Benutzer-Datenbank
$benutzer = @{}
$benutzer["anna"] = @{
Vollname = "Anna Schmidt"
Email = "anna@example.com"
Abteilung = "IT"
Aktiv = $true
}
$benutzer["bob"] = @{
Vollname = "Bob Müller"
Email = "bob@example.com"
Abteilung = "HR"
Aktiv = $true
}
# Benutzer suchen
$username = "anna"
if ($benutzer.ContainsKey($username)) {
$user = $benutzer[$username]
Write-Host "$($user.Vollname) - $($user.Email)"
}
# 3. Server-Konfiguration
$serverConfig = [ordered]@{
Hostname = "SRV01"
OS = "Windows Server 2022"
IP = "192.168.1.100"
RAM_GB = 32
CPU_Cores = 8
Dienste = @("IIS", "MSSQL", "DNS")
Backup = @{
Enabled = $true
Schedule = "Daily"
Target = "\\backup\srv01"
}
}
# Als JSON speichern
$serverConfig | ConvertTo-Json -Depth 3 |
Out-File server_config.json
# 4. Log-Parser
$logEintraege = @()
Get-Content server.log | ForEach-Object {
if ($_ -match "ERROR") {
$logEintraege += [PSCustomObject]@{
Zeitstempel = (Get-Date)
Typ = "Error"
Nachricht = $_
}
}
}
$logEintraege | Export-Csv errors.csv -NoTypeInformation
# 5. Netzwerk-Inventar
$netzwerk = @{
Switches = @(
[PSCustomObject]@{Name="SW01"; IP="192.168.1.1"; Ports=24}
[PSCustomObject]@{Name="SW02"; IP="192.168.1.2"; Ports=48}
)
Router = @(
[PSCustomObject]@{Name="RT01"; IP="192.168.1.254"; Typ="Edge"}
)
AccessPoints = @(
[PSCustomObject]@{Name="AP01"; IP="192.168.1.10"; SSID="Office"}
[PSCustomObject]@{Name="AP02"; IP="192.168.1.11"; SSID="Office"}
)
}
# Alle IPs auflisten
Write-Host "=== Netzwerk-Inventar ==="
foreach ($kategorie in $netzwerk.Keys) {
Write-Host "`n$kategorie :"
$netzwerk[$kategorie] | ForEach-Object {
Write-Host " $($_.Name) - $($_.IP)"
}
}
# 6. Prozess-Monitor mit Historie
$prozessHistorie = [System.Collections.ArrayList]@()
1..5 | ForEach-Object {
$snapshot = Get-Process | Select-Object Name,
@{N='CPU'; E={$_.CPU}},
@{N='MemoryMB'; E={[math]::Round($_.WS/1MB,2)}},
@{N='Zeitstempel'; E={Get-Date}}
$prozessHistorie.AddRange($snapshot) | Out-Null
Start-Sleep -Seconds 10
}
# Top 10 nach CPU über alle Snapshots
$prozessHistorie | Sort-Object CPU -Descending |
Select-Object -First 10 | Format-Table
# 7. Konfigurations-Manager
class ServerConfig {
[string]$Hostname
[string]$Environment
[hashtable]$Settings
ServerConfig([string]$host, [string]$env) {
$this.Hostname = $host
$this.Environment = $env
$this.Settings = @{}
}
[void]AddSetting([string]$key, [object]$value) {
$this.Settings[$key] = $value
}
[object]GetSetting([string]$key) {
return $this.Settings[$key]
}
}
$config = [ServerConfig]::new("SRV01", "Production")
$config.AddSetting("MaxConnections", 1000)
$config.AddSetting("LogLevel", "Info")
Debugging-Tipps für Datentypen
[Bearbeiten | Quelltext bearbeiten]# Typ und Inhalt überprüfen
$variable | Get-Member
$variable.GetType().FullName
# Array vs. einzelnes Element
$array = @(1) # Array mit 1 Element
$single = 1 # Nur Int
$array -is [array] # True
$single -is [array] # False
# Null-Prüfung
if ($null -eq $variable) {
Write-Host "Variable ist null"
}
# Leere Arrays/Hashtables prüfen
if ($array.Count -eq 0) {
Write-Host "Array ist leer"
}
if ($hash.Count -eq 0) {
Write-Host "Hashtable ist leer"
}
# Eigenschaften prüfen
if ($objekt.PSObject.Properties.Name -contains "Eigenschaft") {
Write-Host "Eigenschaft existiert"
}