Zum Inhalt springen

Powershell - Variablen und Datentypen

Aus Gerhards Wiki

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 ✗
💡
Tipp
Verwende aussagekräftige Namen: $benutzerName statt $bn oder $x

Variablen 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!
"@
ℹ️
Hinweis
Verwende doppelte Anführungszeichen ("") für Variablen-Interpolation, einfache () für wörtliche Strings.

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
⚠️
Warnung
Typkonvertierung kann fehlschlagen! Verwende Try-Catch bei unsicheren Konvertierungen.

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 = @()
ℹ️
Hinweis
Dies ist ein allgemeiner Hinweis
$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)
💡
Tipp
Verwende [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)
ℹ️
Hinweis
Kind-Scopes können Eltern-Variablen lesen, aber Änderungen erstellen lokale Kopien!

Praktische Übungen

[Bearbeiten | Quelltext bearbeiten]

Übung 1: Variablen und Strings

[Bearbeiten | Quelltext bearbeiten]

Aufgabe:

  1. Erstelle Variablen für Vorname, Nachname und Alter
  2. Kombiniere sie zu einem vollständigen Satz
  3. Verwende String-Interpolation
  4. 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:

  1. Erstelle ein Array mit 5 Städtenamen
  2. Gib die erste und letzte Stadt aus
  3. Füge zwei weitere Städte hinzu
  4. Sortiere das Array alphabetisch
  5. 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:

  1. Erstelle eine Hashtable für einen Benutzer (Name, Email, Abteilung, Aktiv)
  2. Füge ein weiteres Feld "Telefon" hinzu
  3. Gib alle Keys und Values aus
  4. Prüfe, ob der Key "Email" existiert
  5. Ä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:

  1. Erstelle ein Array mit 3 PSCustomObjects für Produkte (Name, Preis, Lagerbestand)
  2. Filtere Produkte mit Preis > 50
  3. Sortiere nach Preis absteigend
  4. Exportiere in CSV
  5. 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:

  1. Erstelle einen String mit einer Zahl
  2. Konvertiere ihn zu Int und verdopple ihn
  3. Erstelle ein Datum aus einem String "2025-12-24"
  4. Berechne, wie viele Tage bis zu diesem Datum sind
  5. 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:

  1. Erstelle eine Hashtable "Firma" mit Name und Abteilungen
  2. Jede Abteilung ist ein Array von PSCustomObjects (Mitarbeiter)
  3. Jeder Mitarbeiter hat Name, Position, Gehalt
  4. Gib alle IT-Mitarbeiter aus
  5. 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

DO:

  • Verwende aussagekräftige Variablennamen ($benutzerName statt $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"
}
✓
Erfolg
Glückwunsch! Du hast Kurs 3 abgeschlossen und kannst jetzt effektiv mit Variablen und Datenstrukturen arbeiten!