PowerShell 7 und Windows PowerShell

Table of contents

1. Cover
2. Titel
3. Impressum
4. Inhalt
5. Vorwort
   1. Wie Sie dieses Buch nutzen
   2. Achtung
   3. Noch mehr Unterstützung
6. 1 PowerShell: Erste Schritte
   1. PowerShell installieren
   2. Windows-Betriebssystem
   3. PowerShell nachrüsten: macOS und Linux
   4. Kompatibilität der PowerShell
   5. PowerShell einrichten
   6. Vorsicht mit Administratorrechten!
   7. Interaktive Befehle eingeben
   8. Autovervollständigung: Tippfehler vermeiden
   9. Befehlszeilen erneut verwenden
   10. Groß- und Kleinschreibung
   11. Unvollständige und mehrzeilige Eingaben
   12. PowerShell-Hilfe aus dem Internet nachladen
   13. Skriptausführung erlauben
   14. Weitere PowerShell-Einschränkungen
   15. Wichtige PowerShell-Werkzeuge
   16. PowerShell-ISE-Editor
   17. VSCode (Visual Studio Code)
   18. Windows-Terminal
   19. Codebeispiele automatisch herunterladen
   20. Befehl zum Herunterladen von Codebeispielen nachrüsten
   21. Beispielcode in Zwischenablage kopieren
   22. Beispielcode sofort ausführen
   23. Profilskripte: PowerShell dauerhaft anpassen
   24. Einzelne Profilskripte verwenden
   25. Fragen stellen
   26. Alle Skripte herunterladen
   27. Zusammenfassung
   28. Ausführungsrichtlinie festlegen
   29. Hilfe nachrüsten
   30. Windows PowerShell aktualisieren
   31. Hilfsbefehle zum Download von Beispielcode
   32. »Fehlende Befehle« verstehen
   33. Zusätzliche Werkzeuge
7. 2 Überblick: Was PowerShell leistet
   1. Befehle lösen Aufgaben
   2. Literale
   3. Text
   4. Zahlen
   5. Datum und Zeit
   6. Kommentare
   7. Cmdlets: die PowerShell-Befehle
   8. Nach Tätigkeitsbereich suchen (»Noun«)
   9. Nach Tätigkeit suchen (»Verb«)
   10. Nach Herkunft suchen
   11. Standardisierte Verben
   12. Cmdlets per Fenster suchen
   13. Syntax verstehen
   14. Ausführliche Hilfe und Beispiele
   15. Anwendungsprogramme (Applications)
   16. Applications starten
   17. Applications finden
   18. Systembefehle nutzen
   19. Hilfe für Applications abrufen
   20. .NET-Methoden
   21. Methoden verwenden
   22. Hilfe für Methoden
   23. Noch mehr Methoden
   24. Methoden: vielseitiger, aber kleinteiliger
   25. Operatoren
   26. Operatoren nachschlagen
   27. Vergleichsoperatoren
   28. Textoperatoren
   29. Zuweisungen und Pipeline
   30. Zahlenreihen
   31. Befehle verbinden
   32. Das Türchen-Modell
   33. Normalfall: »Türchen 3«
   34. Modernes Pipeline-Streaming: »Türchen 1«
   35. Klassische Variablen: »Türchen 2«
   36. Neue Befehle nachrüsten
   37. Beispiel 1: QR-Codes generieren
   38. Beispiel 2: Automatische HTML-Reports
   39. Beispiel 3: Musik spielen
   40. Zusammenfassung
8. 3 Skripte und Funktionen
   1. PowerShell-Skripte verstehen
   2. Skriptcode eingeben
   3. Skripte mit dem ISE-Editor entwickeln
   4. Neues Skript anlegen
   5. Skripte mit dem VSCode-Editor entwickeln
   6. Neue Skripte anlegen
   7. Skripte ausführen
   8. Skripte innerhalb von PowerShell starten
   9. Skripte außerhalb von PowerShell starten
   10. Skripte automatisch starten
   11. Skriptstart durch Task Scheduler
   12. Profilskripte – die Autostartskripte
   13. Profilskript anlegen und öffnen
   14. Typische Profilskriptaufgaben durchführen
   15. Neue Befehle: Funktionen
   16. Schritt 1: Nützlicher Code
   17. Schritt 2: Als Funktion verpacken
   18. Schritt 3: Parameter definieren
   19. Schritt 4: Funktionen dauerhaft verfügbar machen
   20. Funktionen im Modul permanent verfügbar
   21. Die gemeinsame Grundlage: der Skriptblock
   22. Skripte sind gespeicherte Skriptblöcke
   23. Funktionen sind vorgeladene Skriptblöcke
   24. Module laden Funktionen bei Bedarf in den Speicher
   25. Skript oder Funktion?
9. 4 Cmdlets – PowerShell-Befehle
   1. Parameter steuern Cmdlets
   2. Argumente an Parameter übergeben
   3. Parameter machen Cmdlets vielseitig
   4. Politisch inkorrekt: positionale Argumente
   5. Gratiszugabe: »Common Parameters«
   6. Auf Fehler reagieren
   7. Vielseitigkeit durch Parametersätze
   8. »Schmal, aber tief« – Cmdlets sind Spezialisten
   9. Mehrere Parametersätze: noch mehr Vielseitigkeit
   10. Praxis: Ereignisse aus dem Ereignislogbuch lesen
   11. »ISA/HASA« – wie Cmdlets in der Pipeline funktionieren
   12. Das »ISA/HASA«-Prinzip
   13. Praxisnutzen
   14. Vorteile des Pipeline-Streamings
10. 5 Die PowerShell-Pipeline
    1. Aufbau der PowerShell-Pipeline
    2. Befehle reichen Ergebnisse weiter
    3. Pipeline steuert Befehle
    4. Prinzipieller Aufbau der Pipeline
    5. Die sechs wichtigsten Pipeline-Befehle
    6. Select-Object
    7. Detailinformationen festlegen
    8. Unsichtbare Eigenschaften sichtbar machen
    9. Eine bestimmte Eigenschaft auswählen: -ExpandProperty
    10. Selbst festlegen, welche Informationen wichtig sind
    11. Weitere Informationen anfügen
    12. -First, -Last und -Skip
    13. Berechnete Eigenschaften
    14. Where-Object
    15. Clientseitiger Universalfilter
    16. Leere Elemente aussortieren
    17. Fortgeschrittene Syntax bietet mehr Möglichkeiten
    18. Out-GridView: das »menschliche« Where-Object
    19. Sort-Object
    20. Cmdlet-Ergebnisse sortieren
    21. Sortierung mit anderen Cmdlets kombinieren
    22. Datentyp der Sortierung ändern
    23. Mehrere Spalten in umgekehrter Sortierung
    24. Group-Object
    25. Häufigkeiten feststellen
    26. Daten gruppieren
    27. Berechnete Gruppierungskriterien
    28. Measure-Object
    29. Statistische Berechnungen
    30. Ordnergrößen berechnen
    31. Foreach-Object
    32. Grundprinzip: eine Schleife
    33. Format-Cmdlets
    34. Gefährlich: Format-Cmdlets verändern Objekte
    35. Mehrspaltige Anzeigen
    36. Tabellenausgabe mit Gruppierung
11. 6 Arrays und Hashtables
    1. Arrays verwenden
    2. Auf Array-Elemente zugreifen
    3. Eigene Arrays (und einige Fallen)
    4. Automatische Array-Erzeugung
    5. Manuelle Array-Erzeugung
    6. Hashtables – »sprechende Arrays«
    7. Hashtables in Objekte umwandeln
    8. Neue Objekte mit Eigenschaften initialisieren
12. 7 PowerShell-Laufwerke
    1. Dateisystemaufgaben meistern
    2. Cmdlets für das Dateisystem finden
    3. Erste Schritte
    4. Ordner anlegen
    5. Dateien anlegen und Informationen speichern
    6. Encoding von Textdateien
    7. Encodings sichtbar machen
    8. Dateien finden
    9. Dateien und Ordner kopieren
    10. Dateien umbenennen
    11. Dateien und Ordner löschen
    12. Größe eines Laufwerks ermitteln
    13. Größe eines Ordners ermitteln
    14. Umgebungsvariablen
    15. Alle Umgebungsvariablen auflisten
    16. Auf einzelne Umgebungsvariablen zugreifen
    17. Umgebungsvariablen ändern
    18. Windows-Registrierungsdatenbank
    19. Schlüssel suchen
    20. Werte lesen
    21. Neue Registry-Schlüssel anlegen
    22. Registry-Schlüssel löschen
    23. Werte hinzufügen, ändern und löschen
    24. Virtuelle Laufwerke und Provider
    25. Neue PowerShell-Laufwerke
    26. Ohne Laufwerksbuchstaben direkt auf Provider zugreifen
    27. -Path oder -LiteralPath?
    28. Existenz eines Pfads prüfen
    29. Pfadnamen auflösen
13. 8 Operatoren und Bedingungen
    1. Operatoren – Aufbau und Namensgebung
    2. Wie Operatornamen aufgebaut sind
    3. Unäre Operatoren
    4. Zuweisungsoperatoren
    5. Vergleichsoperatoren
    6. Ternary-Operator
    7. Unterscheidung zwischen Groß- und Kleinschreibung
    8. Unterschiedliche Datentypen vergleichen
    9. Vergleiche umkehren
    10. Vergleiche kombinieren
    11. Vergleiche auf Arrays anwenden
    12. Bedingungen
    13. if-Bedingung
    14. switch-Bedingung
    15. Where-Object
    16. Null-Koaleszenz-Operatoren
    17. Pipeline-Verkettungsoperatoren
14. 9 Textoperationen und reguläre Ausdrücke
    1. Texte zusammenfügen
    2. Doppelte Anführungszeichen lösen Variablen auf
    3. Der Formatierungsoperator -f
    4. Array-Elemente in Text umwandeln
    5. Textstellen finden und extrahieren
    6. Texte splitten
    7. Informationen in Texten finden
    8. Reguläre Ausdrücke: Textmustererkennung
    9. Erste Schritte: Textmuster basteln
    10. Eigene reguläre Ausdrücke konzipieren
    11. Textstellen ersetzen
    12. Einfache Ersetzungen
    13. Sichere Ersetzungen mit -replace
    14. Mehrere Zeichen durch eins ersetzen
    15. Split und Join: eine mächtige Strategie
    16. Dateipfade ändern
    17. X500-Pfade auslesen
15. 10 Anwendungen und Konsolenbefehle
    1. Programme starten
    2. Optionen für den Programmstart festlegen
    3. Argumente an Anwendungen übergeben
    4. Hilfe für Konsolenbefehle anzeigen
    5. Beispiel: Lizenzstatus von Windows überprüfen
    6. Ergebnisse von Anwendungen weiterverarbeiten
    7. Error Level auswerten
    8. Fragen an Benutzer stellen mit choice.exe
    9. Rückgabetext auswerten
    10. Laufende Programme steuern
    11. Feststellen, ob ein Prozess läuft
    12. Auf einen Prozess warten
    13. Einstellungen laufender Prozesse ändern
    14. Prozesse vorzeitig abbrechen
16. 11 Typen verwenden
    1. Typumwandlungen
    2. Geeignete Datentypen auswählen
    3. Explizite Umwandlung
    4. Deutsches Datumsformat mit dem Operator -as
    5. Verkettete Umwandlungen
    6. Typen: optimale Informationsbehälter
    7. Implizite Umwandlung
    8. Typisierte Variablen
    9. Parameter und Argumente
    10. Vergleichsoperationen
    11. Statische Methoden eines Typs verwenden
    12. Dateiextension ermitteln
    13. Mathematische Funktionen
    14. Zahlenformate konvertieren
    15. DNS-Auflösung
    16. Umgebungsvariablen
    17. Pfade zu Systemordnern finden
    18. Konsoleneinstellungen
    19. Spezielle Datumsformate lesen
    20. Statische Eigenschaften verwenden
    21. Neue .NET-Typen finden
    22. Type Accelerators untersuchen
    23. Typen nachladen
    24. Assembly-Namen feststellen
    25. Aktuell geladene Assemblies auflisten
    26. Zusätzliche Assembly nachladen
    27. Assembly aus Datei nachladen
17. 12 Mit Objekten arbeiten
    1. Objekte kennenlernen
    2. Objekte funktionieren wie beschriftete Schubladen
    3. Typisierte Variablen
    4. Objekteigenschaften erforschen
    5. Eigenschaften lesen
    6. Eigenschaften ändern
    7. Methoden verwenden
    8. Zusammenfassende Systematik
    9. Eigenschaften
    10. Methoden
    11. Hilfe finden
    12. Neue Objekte herstellen
    13. Konstruktoren verstehen
    14. Ein Credential-Object zur automatischen Anmeldung
    15. Eigene Objekte erstellen
18. 13 Eigene Typen und Attribute
    1. Typen (Klassen) selbst herstellen
    2. Einen eigenen Typ erfinden
    3. Neue Objekte eines Typs generieren
    4. Konstruktoren hinzufügen
    5. Methoden zum Typ hinzufügen
    6. Vererbung von Typen
    7. Konstruktoren werden nicht geerbt
    8. Philips Hue Smart Home mit Typen steuern
    9. Kontakt zur Philips Hue Bridge herstellen
    10. Lampen- und Schalterinventar
    11. Lampen und Steckdosen ansprechen
    12. Attribute erstellen
    13. SecureString-Transformationsattribute
    14. Auf API-Funktionen zugreifen
    15. API-Funktion einsetzen
    16. Wiederverwertbare PowerShell-Funktion herstellen
19. 14 Parameter für Fortgeschrittene
    1. Argumentvervollständigung
    2. Statische Autovervollständigung
    3. Autovervollständigung über Enumerationsdatentyp
    4. Eigene Enumerationsdatentypen erstellen
    5. Autovervollständigung über ValidateSet
    6. Dynamische Argumentvervollständigung
    7. Zuweisungen mit Validierern überprüfen
    8. ValidateSet
    9. ValidateRange
    10. ValidateLength
    11. ValidatePattern
    12. ValidateCount
    13. ValidateScript
    14. Nullwerte und andere Validierer
    15. Parameter in ParameterSets einteilen
    16. Gegenseitig ausschließende Parameter
    17. Binding über Datentyp
    18. Parameter in mehreren Parametersätzen
    19. Simulationsmodus (-WhatIf) und Sicherheitsabfrage (-Confirm)
    20. Festlegen, welche Codeteile übersprungen werden sollen
    21. Weiterleitung verhindern
    22. Gefährlichkeit einer Funktion festlegen
    23. Dynamische Parameter
    24. Dynamische Parameter selbst definieren
    25. Splatting: Argumente an Parameter binden
    26. Splatting im Alltag einsetzen
    27. Übergebene Parameter als Hashtable empfangen
    28. Mit Splatting Parameter weiterreichen
20. 15 Pipeline-fähige Funktionen
    1. Anonyme Pipeline-Funktion
    2. Prototyping
    3. Pipeline-fähige Funktion erstellen
    4. Benannte Parameter
    5. Where-Object durch eine Funktion ersetzen
    6. Kurzes Resümee
    7. Parameter und Pipeline-Kontrakt
    8. ISA-Kontrakt: Pipeline-Eingaben direkt binden
    9. HASA-Kontrakt: Objekteigenschaften lesen
    10. HASA und ISA kombinieren
    11. CSV-Dateien direkt an Funktionen übergeben
    12. Aliasnamen für Parameter
21. 16 PowerShellGet und Module
    1. PowerShellGet – die PowerShell-Softwareverteilung
    2. Grundlage »PackageManagement«
    3. PowerShellGet – Softwareverteilung per Cmdlets
    4. Wo PowerShell Module lagert
    5. Unterschiede zwischen Windows PowerShell und PowerShell
    6. Installierte Module untersuchen
    7. Module mit PowerShellGet nachinstallieren
    8. Module finden und installieren
    9. Modul herunterladen
    10. Modul testweise ausführen
    11. Modul dauerhaft installieren
    12. Module aktualisieren
    13. Side-by-Side-Versionierung
    14. Eigene Module veröffentlichen
    15. Eigene Module herstellen
    16. Neue Manifestdatei anlegen
    17. Neue Moduldatei anlegen
    18. Modul testen
    19. Nächste Schritte
    20. Eigene Module verteilen
    21. Netzwerkfreigabe
    22. Modul in Repository übertragen
    23. Modul aus privatem Repository installieren
22. 17 Fehlerhandling
    1. Fehlermeldungen unterdrücken
    2. Bestimmen, wie Cmdlets auf Fehler reagieren
    3. Fehler mitprotokollieren lassen
    4. Erfolg eines Befehlsaufrufs prüfen
    5. Fehlerhandler einsetzen
    6. Lokaler Fehlerhandler: try…catch
    7. Globaler Fehlerhandler: Trap
23. 18 Windows PowerShell-Remoting
    1. PowerShell-Remoting aktivieren
    2. Zugriff auch auf Windows-Clients
    3. Remoting-Verbindung überprüfen
    4. NTLM-Authentifizierung erlauben
    5. PowerShell-Remoting überprüfen
    6. Erste Schritte mit PowerShell-Remoting
    7. Befehle und Skripte remote ausführen
    8. Kontrolle: Wer besucht »meinen« Computer?
    9. Remotefähigen Code entwickeln
    10. Argumente an Remote-Code übergeben
    11. Ergebnisse vom Remote-Code an den Aufrufer übertragen
    12. Fan-Out: integrierte Parallelverarbeitung
    13. ThrottleLimit: Parallelverarbeitung begrenzen
    14. Double-Hop und CredSSP: Anmeldeinfos weiterreichen
    15. Eigene Sitzungen verwenden
    16. Eigene Sitzungen anlegen
    17. Parallelverarbeitung mit PSSessions
    18. SSH-basiertes Remoting
    19. SSH-Remoting aktivieren
    20. Enter-PSSession über SSH
    21. Invoke-Command über SSH
    22. Unbeaufsichtigte Ausführung und Parallelbearbeitung
24. 19 Grafische Oberflächen gestalten
    1. Eigene Fenster herstellen
    2. GUI mit Code definieren
    3. GUI mit XAML definieren
    4. Beispiel: Dienststopper-Anwendung
25. Index