TBZIT_M403_WPS_Einführung_V2.5

Technische Berufsschule Zürich TBZ Automobiltechnik Modul 403 Prozedural programmieren mit Windows PowerShell Kellenberger Michael Version 2.5

Technische Berufsschule Zürich Informationstechnik Modul 403 Strukturiert programmieren mit WINDOWS PowerShell Version 2.5 KEL 2/34 1 Inhalt 1 Die integrierte Entwicklungsumgebung ...................................................................................... 4 1.1 PowerShell ISE .................................................................................................................... 4 1.2 Sicherheit beim Einsetzen von Scripts ................................................................................ 4 1.3 ISE kurz erklärt .................................................................................................................... 5 1.4 Aktueller Pfad in der Konsole setzen ................................................................................... 6 1.5 Script-Programme starten .................................................................................................... 6 1.5.1 Übung: Mein erstes WPS-Script (KR T1) ...................................................................... 7 1.5.2 Hilfe zu PowerShell Cmdlets ......................................................................................... 7 1.5.3 Hinweis Variablen (Siehe auch Kap. 3.2 & 3.4) (KR T1, D2) ........................................ 7 1.6 Tastenkürzel ........................................................................................................................ 7 2 Etwas über Objekte (mehr dazu im Modul 404) ......................................................................... 8 2.1 Eigenschaften von Objekten ................................................................................................ 8 2.2 Methoden von Objekten ....................................................................................................... 8 3 Variablen und Operatoren (KR D1) ............................................................................................ 9 3.1 Verwendung von Variablen und Konstanten ....................................................................... 9 3.1.1 .NET Standarddatentypen .......................................................................................... 10 3.1.2 Implizite und explizite Datentypdeklaration (KR D1, D2) ............................................ 11 3.1.3 Automatische Variablenauflösung .............................................................................. 11 3.2 String-Variablen (KR D4) ................................................................................................... 12 3.3 Zahlenkonstanten (KR D2) ................................................................................................ 12 3.4 Automatische Variablen ..................................................................................................... 12 3.5 Typenkonversion (KR D2) ................................................................................................. 13 3.6 Gültigkeitsbereiche (KR D2) .............................................................................................. 14 3.6.1 Übung Gültigkeitsbereiche .......................................................................................... 14 3.7 Mathematische Operatoren (KR I1) ................................................................................... 15 3.7.1 Kurzschreibweise mit einer Variable ........................................................................... 15 3.8 Mathematische Standardfunktionen (KR S4, I4) ............................................................... 15 4 Ein WPS-Script ......................................................................................................................... 16 4.1 EVA-Prinzip und Inline-Kommentar (KR D3, I3) ................................................................ 16 4.1.1 EVA-Prinzip ................................................................................................................. 16 4.1.2 Inline Kommentar ........................................................................................................ 16 4.1.3 Script-Vorlage ............................................................................................................. 17 4.2 Script-Programme starten (KR D2, I3) ............................................................................... 18 4.2.1 Übung: Gültigkeitsbereiche (KR D2) ........................................................................... 18 4.3 Einfache Ein- und Ausgaben (KR I3) ................................................................................. 19 4.4 Ein- und Ausgabe mit Anzeigefenster ............................................................................... 19 5 Kontrollstrukturen (KR S1- S4 à I1 – I4) ................................................................................. 21

Technische Berufsschule Zürich Informationstechnik Modul 403 Strukturiert programmieren mit WINDOWS PowerShell Version 2.5 KEL 3/34 5.1 Vergleichsoperatoren zur Formulierung von Bedingungen (KR D2 I2 I4) ......................... 21 5.2 Entscheidungen (Selektion) ............................................................................................... 22 5.2.1 If-else Entscheidung ................................................................................................... 22 5.2.2 Verschachtelte Entscheidung (Mehrfachentscheidung I) ............................................ 22 5.2.3 If-elseif-else Entscheidung (Mehrfachentscheidung I) ................................................ 22 5.2.4 Switch Entscheidung (Mehrfachentscheidung II) ........................................................ 23 5.2.5 Negation der Bedingung ............................................................................................. 23 5.3 Schleifen (Iteration) ............................................................................................................ 24 5.3.1 While Schleife ............................................................................................................. 24 5.3.2 Do-While Schleife ...................................................................................................... 24 5.3.3 Do-Until Schleife ........................................................................................................ 24 5.3.4 Verwendung einer Laufvariable .................................................................................. 24 5.3.5 For Zähl-Schleife mit Laufvariable .............................................................................. 24 5.3.6 Endlosschleife mit Abbruch (Break) ............................................................................ 25 5.3.7 Übung: Doppelschleife ................................................................................................ 25 6 Fehlermeldungen und Debugging (KR T2, T1) ........................................................................ 26 6.1 Syntax-Fehler .................................................................................................................... 26 6.2 Laufzeit-Fehler und Fehlermeldungen in der Konsole ....................................................... 26 6.3 Debugging mit der ISE ....................................................................................................... 27 7 Standardfunktionen (KR I3, I4, D4) .......................................................................................... 28 7.1 Zähl-Funktionen ................................................................................................................. 28 7.2 String-Funktionen .............................................................................................................. 28 7.2.1 Zeichenketten zusammenfügen .................................................................................. 29 7.2.2 Strings zerlegen .......................................................................................................... 29 7.2.3 Substring extrahieren .................................................................................................. 30 7.2.4 Zeichen suchen und ersetzen ..................................................................................... 30 7.2.5 Zeichenketten vergleichen .......................................................................................... 30 7.3 DateTime-Funktionen ........................................................................................................ 31 7.4 Robuste Eingabe von Daten .............................................................................................. 33

Technische Berufsschule Zürich Informationstechnik Modul 403 Strukturiert programmieren mit WINDOWS PowerShell Version 2.5 KEL 4/34 Strukturiert programmieren mit Windows PowerShell Dieses Skript dient dazu, die geforderten Grundlagen-Kompetenzen des Modul M403 schnell an- gehen zu können. Es gibt lediglich einen ersten Überblick und es ist sinnvoll zur Vertiefung der Module mit Windows PowerShell (M403, M404, M122) ein Buch anzuschaffen. Folgend einige Vorschläge: - Windows PowerShell 5 - kurz & gut, O'Reilly - Windows PowerShell 5 und Core 6: Das Praxisbuch, Hanser (ca. 60.-) (für zukünftige Administratoren à PDF) - Microsoft Windows PowerShell Programming for the Absolute Beginner (englisch) 1 Die integrierte Entwicklungsumgebung 1.1 PowerShell ISE Mit der (automatischen) Installation von Windows PowerShell wird neben der Konsole auch eine Entwicklungsumgebung zum Erstellen und Testen von PowerShell Scrips (Programme) mitinstal- liert. Wir wollen diese ISE bevorzugt verwenden, da sie einige Verbesserungen zur Konsole auf- weist und sie beim Erstellen und Starten von Script-Programmen einiges vereinfacht. 1.2 Sicherheit beim Einsetzen von Scripts Mit dem Windows Scripting Host (WSH) hatte Microsoft mit Windows 2000 eine mächtige Script- Engine eingeführt. Diese Engine war so mächtig, dass sie schnell als neue Angriffsfläche für Viren- Autoren genutzt wurde. Unbedarfte Anwender erhielten schon bald erste Emails mit der Verspre- chung schöner Bilder, jedoch bekam man beim Öffnen des Anhangs nichts zu sehen. Der Anhang entpuppte sich stattdessen als VBScript, welches dem System mächtig zusetze. Windows Po- werShell versucht hier sein Bestes, diesen Bedrohungen entgegenzuwirken. So führt Windows PowerShell in der Grundeinstellung überhaupt keine Skripte aus. Das muss ex- plizit vom Systemadministrator freigeschaltet werden. Die Freischaltung erlaubt dabei unterschied- liche Abstufungen, welche alle mit der Signierung von Skripten zusammenhängen. Zusätzlich ist die Endung der Windows PowerShell (.ps1) mit Notepad verknüpft. Selbst wenn Ihre Umgebung Skripte zulässt, würde ein unbedarfter Doppelklick auf ein Attachement oder eine Datei immer le- diglich Notepad öffnen und einem den Quelltext anzeigen. Auch verlangt PowerShell immer die explizite Pfadangabe „.\\“ für Dateien, die direkt aus dem aktu- ellen Verzeichnis aufgerufen werden sollen, z.B.: PS > .\\setuplocation.ps1 So kann verhindert werden, dass man der Windows PowerShell einen Befehl unterschiebt, den man dort gar nicht erwartet hat. (Viren, Trojaner, etc.) Um Skripte auszuführen, muss man die Sicherheit der Windows PowerShell anpassen. Hierzu gibt 1 es die zwei Befehle, sogenannte Cmdlets , get-executionpolicy und set-executionpolicy. Mit get-executionpolicy fragt man die aktuellen Einstellungen ab. Es gibt dabei die vier Stufen à Mehr zu dem Thema finden Sie auch in der Dokumentation zur Windows PowerShell. 1 Ein Cmdlet ist ein vordefiniertes Befehlszeilentool, das eine bestimmte Aktion ausführen kann. Der Name jedes Cmdlets besteht aus einem bezeichnenden Verb, einem Bindestrich und einem bezeichnenden Nomen.

Technische Berufsschule Zürich Informationstechnik Modul 403 Strukturiert programmieren mit WINDOWS PowerShell Version 2.5 KEL 5/34 Um Skripte auszuführen, muss man die Sicherheit der Windows PowerShell anpassen. ¡ Starten Sie ein neues PowerShell-ISE-Fenster via SU- CHEN Menü- … [Windows PowerShell ISE Als Administrator] ¡ Tippen Sie folgenden Befehl im WPS-Fenster ein: Set-ExecutionPolicy unrestricted 2 ¡ Bestätigen Sie mit „Ja, alle“! Das Scripting ist jetzt freigeschaltet ! 1.3 ISE kurz erklärt 1. Fenster der IDE: Mit $Host kann die aktuelle Host-Version ausgelesen werden. 2. Menü mit den wichtigsten Funktionen. Starten Sie unter Hilfe die PowerS- hell-Hilfe Aktualisierung. 3. Übliche Menütasten um Dateien im Editor (9) laden, bearbeiten und spei- chern zu können. 4. Menütasten, um ein Script – oder Teile davon - zu starten, bzw, zu stoppen. 5. Ein Konsolenfenster mit Fernzugriff starten (Remote Session). 6. Eine externe PowerShell-Konsole star- ten. 7. Anordnung der ISE-Fenster Editor (9) und Konsole (10) steuern 8. Anordnung des ISE-Fensters Befehle (11) steuern 9. Editorfenster mit allen geöffneten Scripts 10. Konsolenfenster mit den eingegebenen Cmdlets und gestarteten Scripts 11. Befehlsfenster. Hier können Cmdlets (Siehe 1.5.2) gesucht, mit Parametern versehen und ge- startet werden 12. Statuszeile mit Debugg-Informationen und Zoomfunktion 2 Falls weiterhin keine Script-Programme gestartet werden können, kann es sein, dass Sie eine 32- und eine 64-Bit Version installiert haben. Stellen Sie sicher, dass beide PowerShell-Versionen freigeschaltet werden (à Anleitungen im Internet: H:> Set-ExecutionPolicy unrestricted –scope currentuser –confirm:$false).

Technische Berufsschule Zürich Informationstechnik Modul 403 Strukturiert programmieren mit WINDOWS PowerShell Version 2.5 KEL 6/34 1.4 Aktueller Pfad in der Konsole setzen Eine leidige Sache ist der aktuelle Pfad in der Konsole (C:\\WINDOWS\\system32). Eingegebene Script-Programme und Dateien werden immer im aktuellen Pfad (lokal) gesucht, d.h. im Windowsverzeichnis, was bestimmt der falsche Ort ist! Besser wäre mal im HOME-Verzeichnis zu suchen, also wählen wir es aus: PS > cd ~ Es macht die Sache noch einfacher, wenn wir den aktuellen Pfad gleich zu Beginn auf unseren Script-Ordner setzen. Am einfachsten geht das folgendermassen: • Downloaden Sie den Ordner „08 Scripts“ in ihr M403-Verzeichnis, wo sich (später auch) ihre eignen Script-Programme zum Starten befinden. • Öffnen Sie das Script-Programm SetupLocation.ps1 im PowerShell-ISE-Editor • Starten Sie das Script mit F5 und beachten Sie den geänderten Pfad in der Konsole. Hinweis: Die im Script-Programm angegebenen Zeilen 12 & 13 können Sie gerne bei all ihren Script- Programmen einfügen, um dieses Umschalten beim Starten zu aktivieren. Siehe auch Script-Programm „Vorlage.ps1“ 1.5 Script-Programme starten Soll ein beliebiges Script-Programm ausgeführt werden, geben die den Dateinamen mit der Pfadangabe (hier der lokale Pfad .\\ ) in die PowerShell Kommandozeile ein: PS > .\\FirstScript.ps1 Sie können das betreffende Script-Programm natürlich auch laden und mit der grünen Play-Taste starten!

Technische Berufsschule Zürich Informationstechnik Modul 403 Strukturiert programmieren mit WINDOWS PowerShell Version 2.5 KEL 7/34 1.5.1 Übung: Mein erstes WPS-Script (KR T1) ¡ Versuchen Sie den Programmcode des Script-Programmes „FirstScript.ps1“zu verste- hen…. ¡ Untersuchen Sie den Inhalt der Variablen nach der Ausführung des Programms. ¡ Ändern Sie das Programm nach Gutdünken ab und testen Sie es... ¡ Was passiert, wenn sie die Gross-Klein-Schreibung ändern? ¡ Wie werden Syntax-Fehler markiert? 1.5.2 Hilfe zu PowerShell Cmdlets Die eingebauten Befehle, sog. Cmdlets (sprich Command-Lets), ermöglichen es uns ver- schiedene Dinge auszuführen. Ein Cmdlet ist immer mit Verb-Bindestrich-Nomen benannt, so dass wir einen Hinweis kriegen, was das Cmdlet in etwa ausführt. Beispiel: „write-host“ schreibt etwas auf die WPS-Konsole. (WPS ist unser Host). Das „et- was“ schreiben wir hinter das Cmdlet, also PS > write-host <etwas> ... Mit dem Cmdlet get-help erhalten Sie eine Hilfestellung zu einem angegebenen Cmdlet PS > get-help write-host -full PS > get-help remove-item -online PS > update-help 1.5.3 Hinweis Variablen (Siehe auch Kap. 3.2 & 3.4) (KR T1, D2) ¡ Im PowerShell werden sog. automatischen Variablen angelegt. Machen sie sich ein Bild über den Inhalt der Variablen: PS > Get-Help about_Automatic_Variables. ¡ Interessant sind vor allem die folgenden Standardvariablen: $args =Array der einer Funktion übergebenen Parameter, $input = hält alle übergebenen Elemente einer Pipe, $_ = hält aktuelles Element einer Schleife oder eines Filters $MyInvocation = aktueller Befehl bzw. aktuelles Script $varXY = Benutzer definierte Variable, etc… 1.6 Tastenkürzel

Technische Berufsschule Zürich Informationstechnik Modul 403 Strukturiert programmieren mit WINDOWS PowerShell Version 2.5 KEL 8/34 2 Etwas über Objekte (mehr dazu im Modul 404) PowerShell ist eigentlich eine rein objektorientierte Script-Sprache. Obwohl die Interaktion mit Windows PowerShell durch die Eingabe von Befehlen als Text erfolgt, basiert sie auf Objekten, nicht auf Text. Die Ausgabe eines Befehls ist ein Objekt. Sie können das Ausgabeobjekt als Ein- gabe an einen anderen Befehl senden. Damit bietet Windows PowerShell eine vertraute Schnitt- stelle für Personen, die schon mit anderen Shells gearbeitet haben, und bietet gleichzeitig neue und hilfreiche Möglichkeiten für die Arbeit mit der Befehlszeile. Dank des erweiterten Konzepts des Sendens von Daten zwischen Befehlen können nun Objekte anstelle von Text gesendet werden. Obwohl Objekte erst im nächsten Modul zum Thema gemacht werden, werden wir hie und da be- reits auf sog. Eigenschaften und Methoden von Objekten zugreifen müssen. Jedes Objekt hat per Definition Eigenschaften (engl. Properties = Datenfelder, Objektvariablen) und Methoden (engl. Methods = Aktionen). Die zu einem Objekt gehörenden Eigenschaften und Methoden kann man per Cmdlet „get-member“, Kurzschreibweise (alias) „gm“, auslesen: PS > get-process prozessname | gm Jede Zeile mit dem Wert „Property“ in der Spalte „MemberType“ beschreibt eine Eigenschaft, die man auslesen (beachte get im Kommentar) und evtl. auch setzen (beachte set im Kommentar) kann. 2.1 Eigenschaften von Objekten Um an eine Eigenschaft (oder Methode) eines Objekts ranzukommen, muss das erzeugende Cmd- let mit seinen Parametern in eine Klammer gesetzt werden! Die Klammer verhindert die verfrühte Ausgabe-Umwandlung in einen Text... (siehe unten) Alternativ kann das Objekt auch in einer Objekt-Variable zwischengespeichert werden. (get-process explorer).Path oder: $ex = get-process explorer $ex.Path Zu beachten ist, dass für ein vernünftiges Resultat, nur ein spezifisches Objekt gemeint sein sollte! Also nicht: (get-process *).Path Weitere nützliche Beispiele: $alleProc = get-process * $array = 1,2,3 $alleProc.count $array.length 2.2 Methoden von Objekten Eine Methode wendet eine Aktion auf das Objekt an. Vergewissern Sie sich, dass die Methode IMMER mit einer (zuweilen leeren) Klammer endet! Ohne Klammer wird nur ein Infotext zur Me- thode ausgegeben! Auch darf kein Leerschlag zwischen Methodenname und der öffnenden Klam- mer stehen! Auch hier müssen Sie eine Klammer um das erzeugende Cmdlet setzen: (get-date \"01/02/2017\").getType() $var = 1.5 \"Zwei Worte\".split() $var.getType()

Technische Berufsschule Zürich Informationstechnik Modul 403 Strukturiert programmieren mit WINDOWS PowerShell Version 2.5 KEL 9/34 3 Variablen und Operatoren (KR D1) 3.1 Verwendung von Variablen und Konstanten Eine Variable ist im Grunde genommen ein „Behälter“ für Daten. Die Daten werden in der Variable gespeichert und können im Verlauf des Programms via Variablennamen (Bezeichner) abgerufen und geändert werden. Man spricht von „Deklaration“ bei der Erzeugung der Variable durch <Inhalt> Namensgebung und Typendefinition (siehe Kap. 3.1.2). 4 Man spricht von „Initialisation“ bei der ersten Zuweisung eines <Var-Bezeichner> Var-A Wertes / Inhaltes. Mittels Cmdlets lässt sich eine Variable (relativ umständlich) deklarieren, initialisieren, ausgeben und wieder löschen: PS > set-variable –name VarA –value 4 PS > set-variable VarA PS > remove-variable VarA Weniger umständlich ist die Kurzschreibweise, welche einer Variable ein $-Zeichen voranstellt: PS > $VarB = 5 PS > $VarB Konstanten behalten den initialisierten Wert bei und können nach der Initialisation nicht mehr ge- ändert werden! Konstanten sind Variablen mit der Option ReadOnly oder Constant: (Keine Kurzschreibweise möglich beim Deklarieren und Initialisieren) PS > Set-Variable SiedepunktH2O -Value 100 –option ReadOnly PS > $SiedepunktH2O Eine Variable kann nun zur Eingabe, Verarbeitung und Ausgabe von Werten verwendet werden: $VarA = read-host \"Geben Sie eine Zahl ein:\" Kontrollfluss $VarB = 7 12 5+7 ergibt 12 $VarResultat = $VarA + $VarB Formaler Ausdruck 5 7 write-host \"Das Resultat ist $VarResultat\" Var-Resultat = Var-A + Var-B Der Ausdruck muss einen Wert ergeben Auswertungsreihenfolge Obige Anweisung speichert eine eingegebene Zahl in der Variable $VarA ab, addiert die Zahl mit 7 und gibt das errechnete Resultat aus! Beachten Sie den „formalen Ausdruck“ der die eigentliche Berechnung beschreibt! Die Auswertung des Aus- drucks erfolgt nach algebraischen Regeln von links nach rechts und das Resultat wird in die be- reitgestellte Variable $VarResultat (Kontrollfluss) gelegt. Natürlich können verschiedene „Arten“ von Zahlen in Variablen abgelegt werden. Obige Beispiele waren ganze Zahlen (Integer), hier nun Fliesskommazahlen: $pi =3.1415 $pi1=3.141592653 $pi2=3141592653e-9 -9 Hier wurde die Exponentialschreibweise (e-9 oder E-9 = *10 ) zur Eingabe von Pi verwendet! $pi1 und $pi2 sind somit gleichwertig: -9 3141592653e-9 à 3141592653*10 à 3.141592653 Weiteres Beispiel: 3.141592653e9 à 3141592653*10 à 3‘141‘592‘653 9

Technische Berufsschule Zürich Informationstechnik Modul 403 Strukturiert programmieren mit WINDOWS PowerShell Version 2.5 KEL 10/34 PowerShell speichert die Daten automatisch in einem Format (= Datentyp) ab, das ausreichend ist, um diese Daten richtig zu behandeln. Man nennt diesen Mechanismus „implizite Datentypenzu- weisung“! Dieser Mechanismus kann auch zu ungewollten und schwer zu findenden Fehlern füh- ren und sollte vermieden werden! Siehe 3.1.2! 3.1.1 .NET Standarddatentypen $true / $false 'a' [bool]Var [char]Var Werfen wir nun einen Blick auf die vorgegebenen „Behäl- 34'729 \"Hello world\" terarten“, den sog. Datentypen. Wir wollen den jeweils am [int]Var 2.83434*10 34 [string]Var 12. Nov. '17 besten geeigneten Behälter für unserer Daten benutzen! [double]Var Datentypen 10h10m01s34 [datetime]Var Kategorie Datentyp Beschreibung (Platzbedarf) Wertebereich Ganzzahlig Byte Ganze Zahl ohne Vorzeichen. (8 Bit) 0 bis 255 Int, Int32 Ganze Zahl mit Vorzeichen (32 Bit) -2‘147‘483‘648 bis +2‘147‘483‘647 UInt32 Ganzzahl ohne Vorzeichen (32 Bit) 0 bis +4‘294‘967‘295 Long, Int64 Ganzzahl mit Vorzeichen + 9‘223‘372‘036‘854‘775‘807 bis (64 Bit = 8 Byte im Speicher) - 9‘223‘372‘036‘854‘775‘807 Gleitkomma Single Gleitkommazahl einfacher Genauig- +3.402823e+38 bis -3.402823e+38 & keit (32 Bit). +3.402823e-38 bis -3.402823e-38 Double Gleitkommazahl doppelter Genauig- + bis -1.79769313486232E+308 und keit (64 Bit). + bis -1.79769313486232E-308 Logisch Boolean Ein boolescher Wert (1 Byte). 0 / 1, $false / $true Zeichen Char Unicode-Zeichen (16 Bit). Ein Unicode Zeichen Text String Eine unveränderliche Zeichenfolge Beliebiger Text \"....\" fester Länge mit Unicode-Zeichen. Datum, Zeit DateTime Datum und / oder Zeit kann formatiert Formatierte Datum- und oder Zeitan- gespeichert werden. gabe: TT/MM/JJJJ ST:MN:SC.MS Klassen- Object «Link» zum Objekt, d.h. es kann auf Beliebiges Objekt objekte Objekt zugegriffen werden. (64-Bit-Referenz) 3 Folgendermassen können die entsprechenden Wertebereiche angezeigt werden: [int32]::MaxValue [system.int32]::MinValue Anzeige des (automatisch gesetzten) Datentyps mit der Methode .getType(): $varA = 1 $varRes = 1.234 $varA.getType() $varRes.getType() (\"01/12/17\").gettype() Weitere Datentypen des .NET-Frameworks können hier eingesehen werden: http://msdn.microsoft.com/de-de/library/hfa3fa08%28v=VS.80%29.aspx 3 mit [...] wird die –NET Systembibliothek nach dem angegebenen Modul (Assembly) durchsucht und die nach dem :: folgende statische Eigenschaft oder Methode() aufgerufen

Technische Berufsschule Zürich Informationstechnik Modul 403 Strukturiert programmieren mit WINDOWS PowerShell Version 2.5 KEL 11/34 3.1.2 Implizite und explizite Datentypdeklaration (KR D1, D2) PowerShell setzt bei jeder Deklaration einen geeigneten Datentyp automatisch, falls der Pro- grammierer keinen angibt. Dies nennt sich implizite Typenzuweisung. Diese Anpassung pas- siert auch bei jeder weiteren Rechnung: $var=6 $var.getType() à $var ist Int32 $var=$var+2147483647.43 $var.getType() à $var wird zu Double Wir sehen hier, dass PowerShell automatisch einen grösseren \"Behälter\" für die Variable wählt, um das Resultat noch korrekt, d.h. ohne Überlauf-Fehlermeldung, abspeichern zu können! Da dies zu schwer auffindbaren Fehlern führen kann, sollten wir einen bestimmten Datentyp immer explizit zu setzen. Das tun wir mit dem vorangestellten [Typ] bei der Deklaration: [int]$intVar =9/2; #wird aufgerundet! write-host \"`$intVar = $intVar ist ein 32-Bit Integer mit dem Wert $intVar\" [double]$dblVar=0.9 write-host ($dblVar + 4) à Ergibt 4.9 (rationale Zahl) Siehe auch http://www.PowerShellpraxis.de/index.php/die-variablen Wir wollen im Script immer die explizite Variablendeklaration einsetzen (=gute Programmierpraxis). Folgender Befehl überprüft beim Starten diese strickte Deklarationspflicht und verhindert die leidige Angewohnheit von PowerShell, den Datentyp einer Variable beliebig anzupassen: set-psdebug -strict 3.1.3 Automatische Variablenauflösung Wenn der Befehl (oder der Ausdruck) nicht in Anführungszeichen eingeschlossen werden, oder wenn der Befehl (oder Ausdruck) in doppelte Anführungszeichen (\") eingeschlossen wird, wird die Variable mit dem Inhalt der Variablen ersetzt (=Variablenauflösung): $var=1 write-host \"Ausserhalb:\" $var à Ausserhalb:1 write-host \"Innerhalb $var\" à Innerhalb 1 Wenn der Befehl in einfache Anführungszeichen (') eingeschlossen wird, wird der Variablenname im Ausdruck verwendet: Write-host 'Kein Ersetzen: $var' à Kein Ersetzen: $var Dieser Mechanismus ist insbesondere bei der Initialisierung von String-Variablen wichtig: $strVar = \"Hallo `n $ENV:SystemRoot\" write-host $strVar à Hallo C:\\Windows $strVar = 'Hallo `n $ENV:SystemRoot' write-host $strVar à Hallo `n $ENV:SystemRoot

Technische Berufsschule Zürich Informationstechnik Modul 403 Strukturiert programmieren mit WINDOWS PowerShell Version 2.5 KEL 12/34 3.2 String-Variablen (KR D4) Eine Stringvariable ist eine Zeichenkette, bei der alle Buchstaben einzeln als (Unicode-)Zeichen abgelegt sind und intern durchnummeriert werden. Dabei hat der erste Buchstabe den Index 0, der zweite den Index 1, usw. : $text = \"Hallo Caesar!\" ß Index $text.length à 13 $text[6] à“C“ Zeichenkette können zusammengeführt, verkettet werden: write-host \"abc\" + \"def\" Beachten Sie, dass so gespeicherte Zahlen auch als einzelne Zeichen abgelegt und als String weiterverarbeitet werden: str 1 2 3 . 1 2 3 0 1 2 3 4 5 6 ß Index PS > [string]$str = \"123.123\" PS > $str + 456 à 123.123456 456 wird also nicht addiert, sondern als Zeichenkette angehängt. Siehe auch Kap. 6 Standardfunktionen mit Strings! 3.3 Zahlenkonstanten (KR D2) Folgende Zahlenkonstanten können verwendet werden, um eine bestimmte Datengrösse zu set- zen: $varKB=1kb; $varMB=1mb; $varGB=1gb; write $varKB $varMB $varGB Hexadezimale Zahlen können folgendermassen eingegeben werden: $varHex = 0xFFFF write $varHex Um bestimmte Datentypen zu generieren, können auch bestimmte Buchstaben an die Zahlen an- gehängt werden: $lngVar=1234567890L Write-host \"`$lngVar = $lngVar ist eine Long-Variable = 64-Bit-Integer\" 3.4 Automatische Variablen PowerShell besitzt diverse automatisch generierte Variablen. Mit dem Befehl get-help about_automatic_variables ist die Liste der Variablen mit deren Bedeutung einsehbar! Siehe auch Kapitel 1.5.3! Die Variable $profile zum Beispiel ermöglicht das Definieren von PowerShell-Startup- Funktionen. Siehe auch folgender Link: http://technet.microsoft.com/de-de/library/dd347675.aspx

Technische Berufsschule Zürich Informationstechnik Modul 403 Strukturiert programmieren mit WINDOWS PowerShell Version 2.5 KEL 13/34 3.5 Typenkonversion (KR D2) Verwendete Variablen werden (wie in 3.1.2 beschrieben) vorzugsweise explizit vom Programmie- rer deklariert oder implizit von PowerShell gewählt. Oft benötigt man bei der Verarbeitung von Da- ten eine Umwandlung (=Konversion) der Datentypen. Eine Umwandlung von einer \"kleineren in eine grössere\" Variable ist nie ein Problem: [boolean]à [char]à [int]à[long]à[single]à[double] à[datetime] à[string] • Spezielle Datentypen (boolean / char / datetime / Umwandlung mit Datenverlust object) lassen sich evtl. nur beschränkt konver- 6 2.83434563...*10 6 tieren! 283'434 2.834345*10 • \"String\" speichert auch Zahlen (als einzelne Zif- [single]Var [double]Var fern). Man kann aber nicht direkt damit rechnen [int]Var à PLZ. Umwandlung ohne Datenverlust Datentypenkonversion Eine Umwandlung von einer \"grösseren in eine kleinere\" Variable hingegen schon: • Wenn der konkrete Inhalt der grösseren Variable den Wertebereich der kleineren Variable sprengt, gibt es einen Laufzeitfehler! • Ausnahme: Wenn nur der Nachkommabereich zu gross ist, wird dieser kurzerhand abge- schnitten (und gerundet). Es erfolgt evtl. also ein Datenverlust! • Spezielle Datentypen (boolean / char / datetime / object) lassen sich nur beschränkt kon- vertieren! Die Umwandlung erfolgt mit dem sog. Cast-Operator, der nichts anderes ist als einer der Variable vorangestellten Typenbezeichnung in eckigen Klammern: (Nicht zu verwechseln mit der expliziten Typenangabe bei der Deklaration, die links vom Gleichheitszeichen steht!) $intZahl = [int](3/2) à Das rat. Resultat (=1.5) wird aufgerundet $dblZahl = [double]$strEingabe à Rationale Zahl wird aus Text extrahiert falls möglich, sonst Laufzeitfehler $strPLZ = [string]$intZahl à Aus der Zahl wir ein PLZ-Text generiert $sngZahl = [single]$dblZahl à DoubleZahl in der Genauigkeit beschneiden $intZahl = [int]read-host\"...\" à Text-Eingabe in ein Integer umwandeln falls möglich, sonst Laufzeitfehler** ( 1.34 –as [String]) à Typenkonvertierung mit Operator* *) Typenbestimmung mit Operator: ($a –is [int]) ß Verwendung mit if(..) Typenbestimmung mit Methode: $a.getType() **) Bei der Eingabe sind die Daten grundsätzlich in eine String-Variable zu speichern, da die Daten von der Tastatur gelesen werden. D.h. es können (ungewollt) immer Zahlen, Buchsta- ben oder Sonderzeichen dabei sein. [string]$strEingabe = read-host \"Bitte geben Sie eine ganze Zahl ein:\" Zur Weiterverarbeitung sollte die Eingabe in eine dem Typ angepasste Variable umgewan- delt werden. Zu erwähnen ist bei diesem Beispiel, dass vor der Umwandlung eine Prüfung des Inhaltes erfolgen sollte. Siehe robuste Dateneingabe Kap. 7.4! $intZahl = [int]$strEingabe

Technische Berufsschule Zürich Informationstechnik Modul 403 Strukturiert programmieren mit WINDOWS PowerShell Version 2.5 KEL 14/34 3.6 Gültigkeitsbereiche (KR D2) 4 Variablen und andere Datenelemente können in unterschiedlichen Bereichen aktiv sein. Bei der Deklaration und beim Zugriff bestimmt die Bereichsangabe den Gültigkeitsbereich (Scope): ¡ Variablen im globalen Bereich sind in allen untergeordne- ten Bereichen permanent veränderbar. D.h. die Variable wird in der Konsolenumgebung gespeichert und ist in allen WPS Func lokal Skripten und in der Shell (=Konsole) zugänglich. Somit WIN Script script Session könnten Werte von einem Script in ein anderes übergeben Func lokal werden. global ¡ Variablen im Scriptbereich sind nur innerhalb einer Skript- WPS WPS Func lokal script Shell datei und den untergeordneten Bereichen permanent ver- Script Func lokal änderbar. Hinweis für M122: Bei der Kommunikation zwischen Forms und EventHandlern ist diese Bereichsangabe zwingend! * ¡ Variablen im lokalen Bereich sind nur im aktuellen Bereich (meistens Funktion) und dem unter- geordneten Bereich permanent veränderbar. Ohne explizite Angabe ist eine Variable in diesem Bereich gültig (Standard)! ¡ Variablen im privaten Bereich sind nur im aktuellen Block {...} veränderbar. Praktische Anwendung: Lokale Variablen, z.B. dblVar, können in verschiedenen Scripts deklariert und benutzt werden, ohne dass Sie sich gegenseitig beeinflussen, d.h. es existieren mehrere Variablen mit dem glei- chen Namen, aber eben in unterschiedlichen Gültigkeitsbereichen (lokal im entsprechenden Script). Will man nun Script-übergreifend Informationen weiterleiten, setze ich eine bestimmte Va- riable „global“ – diese gibt’s dann nur noch einmal – und kann von überall her darauf zugreifen (und verändern)! Beispiele zur Deklaration: [int]$global:gblVar = 610341 #--> ISE* [string]$script:answer = \"Taste gedrückt\" #Siehe M122 [double]$local:dblVar = 3.14152345678e4; #Standard Konsole [int]$private:i = 0; #z.B. Schleifenzähler *) Leider führen Versuche, Beispiele im ISE mit Scripts zu kreieren, ins Leere, da alle ISE- Fenster im gemeinsamen Bereich Global (AllScope) laufen! Somit können alle Variablen im- mer verändert und eingesehen werden (= Debug-Modus). Ausnahmen sind selbst definierte Funktionen in der Konsole! 3.6.1 Übung Gültigkeitsbereiche Eine gute Beispielübung finden Sie hier: https://www.windowspro.de/script/gueltigkeitsbereich-scope-von-variablen-PowerShell Zu beachten: Die Beispielprogramme nicht speichern, sondern ungespeichert ausführen!! Achtung: Die Gültigkeitsbereiche werden besonders durch die Art des Scriptaufrufes bestimmt! Studieren Sie dazu die Kapitel 4.1 und 4.2.1 und spielen Sie das dortige Demobeispiel durch! 4 Die Gültigkeitsbereiche sind vor allem durch die jeweilige Ausführungsart mit der PowerShell-Umgebung bestimmt: . oder & Operator! Normalerweise arbeiten wir in diesem Modul NUR im Scriptbereich, da immer dieselbe PowerShell-Umgebung verwendet wird.

Technische Berufsschule Zürich Informationstechnik Modul 403 Strukturiert programmieren mit WINDOWS PowerShell Version 2.5 KEL 15/34 3.7 Mathematische Operatoren (KR I1) Die PowerShell-Sprache kennt, wie viele andere Script-Sprachen auch, verschiedene Operator- Typen. Bei den arithmetischen Operatoren hat der Entwickler die Auswahl zwischen +, -, *, / und %, wobei % den sogenannten Modulo-Operator darstellt, der den Rest einer ganzzahligen Division zurückgibt. Ein Beispiel für Operationen mit Variablen: $a = 4, $b = 29, $c = $a + $b à $c = 33 $d = $b / $a à $d = 7.25 [Double] $rest = $b % $a à $rest = 1 Hinweis: Auch mit dem Datentyp DateTime kann gerechnet werden! Siehe auch Kapitel 7 3.7.1 Kurzschreibweise mit einer Variable Wenn nur eine Variable verändert wird kommt die Kurzschreibweise zum Einsatz. Über spezielle Zuweisungsoperatoren kann die erste Zeile auch verkürzt geschrieben (zweite Zeile) werden: $a = $a + 2 $a += 2 Ebenso kann mit den anderen arithmetischen Operatoren verfahren werden: -=, *=. /=, %= Mit Inkrementoperatoren kann die erste Zeile auch verkürzt geschrieben (zweite Zeile) werden: $a = $a + 1 $a++ #Inkrement des Variableninhaltes von $a $a = $a - 1 $a-- #Dekrement des Variableninhaltes von $a 3.8 Mathematische Standardfunktionen (KR S4, I4) Weitere Standard-Operatoren können via .NET Bibliotheksfunktionen aufgerufen werden: http://msdn.microsoft.com/de-ch/de/library/system.math%28v=vs.110%29.aspx [System.Math] | Get-Member -Static -MemberType Methods $wurzel = [math]::sqrt([decimal] $zahl) $quadrat = [math]::pow([decimal] $zahl, 2) $sinus = [math]::sin([decimal] $zahl) $pi = [math]::pi

Technische Berufsschule Zürich Informationstechnik Modul 403 Strukturiert programmieren mit WINDOWS PowerShell Version 2.5 KEL 16/34 4 Ein WPS-Script PowerShell-Scriptdateien sind einfache Textdateien mit der Dateiendung „ps1“ oder einfach „.ps“. Das „ps“ steht dabei für PowerShell. In der Standardkonfiguration startet ein Doppelklick auf eine derart ausgezeichnete Datei nicht den Befehlsinterpreter, wie es beim WSH/VBS der Fall ist. Es öffnet sich lediglich, ganz unspektakulär, das Notepad oder der Power-GUI Script Editor und zeigt den Scriptcode an. 4.1 EVA-Prinzip und Inline-Kommentar (KR D3, I3) Einfache Programme, insbesondere Script-Programme, sollten zwecks Übersichtlichkeit und Wart- barkeit gemäss dem sog. EVA-Prinzip programmiert, sauber strukturiert und mit Inline- Kommentaren versehen werden. In diesem Modul lernen wir vor allem die Art, wie man ein Pro- gramm prozedural entwickelt: Programmierte Funktionen greifen auf (eingegebene) Daten zu, verarbeiten diese sinnvoll gemäss Aufgabenstellung und geben die Resultate (Daten) wieder aus. 4.1.1 EVA-Prinzip Das EVA-Prinzip beschreibt ein Grundprinzip der Datenver- arbeitung. Die Abkürzung leitet sich aus den ersten Buch- staben der Begriffe Eingabe, Verarbeitung und Ausgabe ab. Diese drei Begriffe beschreiben die Reihenfolge, in der Da- ten verarbeitet werden. Ein einfachstes WPS-Script sieht dann so aus: # Eingabe: [int]$alter = Read-Host \"Geben Sie nun bitte ihr Alter ein: \" #Verarbeitung: [int]$jahr = get-Date -format yyyy [int]$Geburtsjahr = $jahr - $alter #Ausgabe: Write-Host \"Sie sind im\" $Geburtsjahr \"geboren!\" 4.1.2 Inline Kommentar Jeder Programmierer ist angehalten, seinen Programmcode so zu schreiben dass er von einem anderen Programmierer gelesen, verstanden, weiterentwickelt und gewartet werden kann. Dazu gehören die sog. Code-Konventionen (Siehe M404) und guter, im Code eingefügter Kommentar, den sog. Inline-Kommentar. Sinnvollerweise wird jedes Programm mit einem klaren Kommentartitel (Header) versehen. Dazu verwendet man am besten die Kommentar-Klammer: <# … #> <# Mein erstes WPS-Skript ====================== KEL, Datum Version: 1.0 Version 1.1: NAME, 26.09.15 Version 1.2: NAME, 3.10.15 #>

Technische Berufsschule Zürich Informationstechnik Modul 403 Strukturiert programmieren mit WINDOWS PowerShell Version 2.5 KEL 17/34 Jeder Abschnitt sollte zudem mit einem Abschnittstitel versehen werden. Dazu benutzen Sie das einleitende Zeichen #. à Siehe oben! Besonders komplexe oder undurchschaubare Programmzeilen können ebenfalls mit diesem Kom- mentarzeichen kommentiert werden. }elseif ( isnumeric($strZahl)) { # Funktion testet ob Var eine Zahl ist $lngZahl = [long]$strZahl # Umwandlung String --> Long 4.1.3 Script-Vorlage Da die ersten Programme alle in etwa den gleichen Aufbau aufweisen, macht es Sinn eine Vorlage zu erstellen und zu verwenden. Hier eine Vorlage, die auf dem BSCW abgelegt ist. Versuchen Sie speziellen Codezeilen anhand der Kommentare zu verstehen und passen Sie den Header für sich an. Danach sollten Sie immer diese Vorlage verwenden: # <Titel> ###################### # <Beschreibung> # Version 0.1: <Name>, <Datum> # Zwingende Variablendeklaration einschalten: set-psdebug -strict # Aktueller Scriptpfad einlesen und als akt. Pfad setzen [String] $scriptpath = Split-Path $MyInvocation.MyCommand.Path Set-Location $scriptpath #Funktionen laden (nur wenn gebraucht wird!) ... #Variablenliste: #Deklaration, Initialisierung Variablen & konstanten, Kommentar zur Verwendung [int]$intVar = 0 # Eingabe einer ganzen Zahl ... [double]$dblVar = 0 # Resultat der Berechnung ... #Eingabe $intZahl = Read-Host \"Eingabe:\" #Verarbeitung: $dblVar = ... #Ausgabetext zusammensetzen und anzeigen Write-Host \"Ausgabe: \"

Technische Berufsschule Zürich Informationstechnik Modul 403 Strukturiert programmieren mit WINDOWS PowerShell Version 2.5 KEL 18/34 4.2 Script-Programme starten (KR D2, I3) Soll eine Script-Datei ausgeführt werden, bieten sich nach der Freischaltung mit set-executionpolicy remotesigned im PowerShell-ISE ,in der PowerShell-Konsole oder aus ei- nem anderen Script heraus folgende Möglichkeiten an. PS C:\\User\\name> . \"c:\\beispiel.ps1\" Ein Script, das mit \".\" aufgerufen wird, läuft im aktuellen Gültigkeitsbereich. Das Script kann damit auf die derzeit aktuellen Variablen zugreifen und auch neue hinzufügen, die für den Pro- grammteil, der das Script aufgerufen hat, dann auch sichtbar sind. PS C:\\User\\name\\Desktop> & .\\beispiel.ps1 Wird ein Script dagegen mit \"&\" gestartet, läuft es in seinem eigenen neuen Gültigkeitsbereich und ist somit unabhängig vom Script (und dessen Variablen), das den Aufruf getätigt hat. PS C:\\ > & \"~\\Desktop\\beispiel.ps1\" Die Script-Datei muss immer mit den Pfadangaben angegeben werden. Entweder absolut, lokal (.) oder vom HOME-Verzeichnis (~) aus: 4.2.1 Übung: Gültigkeitsbereiche (KR D2) Starten Sie folgendes Script: CallScript.ps1. Das Script ruft zwei mal ein weiteres Script auf: ScriptCalled.ps1. Analysieren Sie die Script-Programme und untersuchen Sie die Ausgaben. Interpretieren Sie die Resultate: - -

Technische Berufsschule Zürich Informationstechnik Modul 403 Strukturiert programmieren mit WINDOWS PowerShell Version 2.5 KEL 19/34 4.3 Einfache Ein- und Ausgaben (KR I3) Schauen Sie sich das Script „FirstScript.ps1“ nochmals an. Dort wird mit Read-Host eine Eingabeaufforderung in der PowerShell Konsole ausgegeben. Der eingegebene Text wird nach der betätigten Eingabetaste in die vor dem Gleichheitszeichen stehende Variable gespeichert. Der Datentyp ist dabei String! Wenn eine Umwandlung in einen anderen Typ gewünscht ist, sollte der Variablentyp angegeben werden (siehe $alter). Zu beachten ist, dass eine Falscheingabe zu einer Fehlermeldung führt und der alte Wert in der Variable $alter weiterverwendet wird! Mit Write-Host (oder kurz Write oder ganz weglassen) werden die nachfolgenden Angaben nacheinander ausgegeben. Berechnungen kann man in einer Klammer vorher ausrechnen lassen, so dass das Resultat erscheint. 4.4 Ein- und Ausgabe mit Anzeigefenster Schauen Sie sich nun das Script „EinAusgabeMitFenster.ps1“ an. Hier werden die Funktio- nen Get-Input und Show-MsgBox verwendet, um Benutzerinteraktionen zu erreichen.

Technische Berufsschule Zürich Informationstechnik Modul 403 Strukturiert programmieren mit WINDOWS PowerShell Version 2.5 KEL 20/34 Erklärungen zu den Programmzeilen: 1] Aussagekräftiger Titel (Kommentar) 4-5] Programmierer Kürzel und Versionsnummern (Kommentar) 7-9] Scriptpfad lokal setzen 12-13] Lokale Funktionen einbinden (eigentlich ausführen, aber da es nur Funktionen sind, werden diese nur geladen) 20] Funktionsaufruf mit Parameter: Titel, dann Ausgabetext und noch Standardwert 21] Zusammensetzen des Ausgabetextes, hier in separater Zeile 22] Funktionsaufruf mit Parameter: Ausgabetext, Titel, Zeichen und Tasten. Man beachte, dass jeder Parameter mit einem Leerzeichen getrennt ist. Man kann hier also nicht mehr Text zusammenfügen wie bei Write-Host 26] Funktionsaufruf mit Parameter: Hier werden die Parameter wie bei 22 gesetzt aber vor- her in den Klammern entsprechend zusammengeführt! Siehe auch http://blog.danskingdom.com/PowerShell-multi-line-input-box-dialog-open-file-dialog- folder-browser-dialog-input-box-and-message-box/

Technische Berufsschule Zürich Informationstechnik Modul 403 Strukturiert programmieren mit WINDOWS PowerShell Version 2.5 KEL 21/34 5 Kontrollstrukturen (KR S1- S4 à I1 – I4) 5.1 Vergleichsoperatoren zur Formulierung von Bedingungen (KR D2 I2 I4) Vergleichsoperatoren werden zur Formulierung von Bedingungen bei Selektionen oder Iterationen verwendet. Es können jedoch nicht die aus anderen Programmiersprachen bekannten Operatoren =, >, <, etc. eingesetzt werden. PowerShell kennt folgende Operatoren: -eq (equals, =) -ne (not equals, != / <>) -gt (greater than, >) -ge (greater or equal, >=) -lt (lower than, <) -le (lower or equal, <=) -or ODER-Verknüpfung:(($a –ge \"A\") –or ($a –le \"Z\")) -and UND-Verknüpfung:(($a –ge \"A\") –and ($a –le \"Z\")) -is Typenbestimmung: ($a –is [int]) -as Typenkonvertierung: ( 1 –as [String]) -like Zeichenvergleich mit Wildcards:($a –like \"*Text*\") -match Zeichenvergleich mit Muster: ($a –match \"[0-9]\") -contains Enthält best. Zeichen: (1,2,3 –contains 1) -notcontains Enthält Zeichen nicht: (1,2,3 –notcontains 4) Folgende Befehlszeile liefert $true: 5 -ge 4 Hilfreich sind oft auch Zeichenketten-Suchbefehle über Wildcards (Operator -like) oder reguläre Ausdrücke (-match). So liefert etwa folgender Vergleich $true: \"abc\" -like \"a*\" Dabei wird die Gross- / Kleinschreibung nicht berücksichtigt. Ist dies jedoch erforderlich, kann - clike beziehungsweise -cmatch eingesetzt werden.

Technische Berufsschule Zürich Informationstechnik Modul 403 Strukturiert programmieren mit WINDOWS PowerShell Version 2.5 KEL 22/34 5.2 Entscheidungen (Selektion) Führt einen Befehlssatz aus, wenn eine Bedingung erfüllt ist. Beachten Sie, die unterschiedlichen Klammern: (...) enthalten die Bedingung, {…} fassen mehrere Befehle zu einem Block zusammen. 5.2.1 If-else Entscheidung Einseitige und zweiseitige Entscheidungen lassen sich folgendermassen programmieren: $Variable = \"Rot\" if ($Variable -eq \"Rot\") {#Einseitige Entscheidung ... \"Die Farbe ist rot!\" ... } #kein else!! $Variable = \"Grün\" if ($Variable -eq \"Rot\") {#Zweiseitige Entscheidung ... \"Die Farbe ist rot!\" ... } else { ... \"Eine andere Farbe...\" ... } Praktisches Beispiel: $myDir = Read-Host \"Bitte einen Pfad eingeben\" if (Test-Path -path $myDir){ Write-Host \"Pfad vorhanden\" } else { Write-Host \"Pfad nicht vorhanden\" } 5.2.2 Verschachtelte Entscheidung (Mehrfachentscheidung I) Entscheidungen lassen sich folgendermassen verschachteln: $Variable = \"Grün\" if ($Variable -eq \"Rot\") ... \"Die Farbe ist rot!\" ... } else { if ($Variable -eq \"Blau\") { ... \"Die Farbe ist blau!\" ... } else { ... \"Eine andere Farbe...\" ... } } 5.2.3 If-elseif-else Entscheidung (Mehrfachentscheidung I) Verschachtelte Entscheidungen lassen sich mit elseif vereinfachen: $Variable = \"Rot\" if ($Variable -eq \"Rot\") { ... \"Die Farbe ist rot!\" ... } elseif ($Variable -eq \"Blau\"){ ... \"Die Farbe ist blau!\" ... } else { ... \"Eine andere Farbe...\" ... }

Technische Berufsschule Zürich Informationstechnik Modul 403 Strukturiert programmieren mit WINDOWS PowerShell Version 2.5 KEL 23/34 5.2.4 Switch Entscheidung (Mehrfachentscheidung II) Eine komfortablere Möglichkeit, Befehlssätze mit mehreren Bedingungen auszuführen: $Variable = \"Rot\" switch ($Variable) { \"Rot\" {\"Die Farbe ist rot!\"} \"Blau\" {\"Die Farbe ist blau!\"} default {\"Eine andere Farbe...\"} } Siehe auch Optionen -wildcard und -case zu switch: switch –wildcard (dir C:\\Windows) { *.dll {$dll++} *.txt {$txt++} *.log {$log++} } write-host \"dlls: $dll text files: $txt log files: $log\" 5.2.5 Negation der Bedingung Bedingungen negieren mit !(...): !( $true ) if (!(test-path fk:)) { write-host \"Laufwerk fk: existiert nicht\" }

Technische Berufsschule Zürich Informationstechnik Modul 403 Strukturiert programmieren mit WINDOWS PowerShell Version 2.5 KEL 24/34 5.3 Schleifen (Iteration) 5.3.1 While Schleife Führt eine kopfgesteuerte Schleife aus, SOLANGE die Bedingung erfüllt ist: $Variable = 1 Struktogramm While ($Variable -lt 10) { $Variable = 1 $Variable Solange $Variable < 10 $Variable++ ... $Variable } $Variable = $Variable + 1 5.3.2 Do-While Schleife Führt eine fussgesteuerte Schleife aus, SOLANGE die Bedingung erfüllt ist: $Variable = 1 Do { Struktogramm $Variable = 1 $Variable ... $Variable $Variable++ $Variable = $Variable + 1 ... } While ($Variable -lt 10) Solange $Variable < 10 5.3.3 Do-Until Schleife Führt eine fussgesteuerte Schleife aus, BIS die Bedingung erfüllt ist: $Variable = 1 Struktogramm Do { $Variable = 1 $Variable ... $Variable $Variable++ $Variable = $Variable + 1 ... } Until ($Variable -gt 10) Bis $Variable > 10 5.3.4 Verwendung einer Laufvariable Bei Iterationen werden häufig sog. Laufvariablen eingesetzt, die den aktuellen Schleifendurch- gang mitzählen oder einfach den Schleifenstatus definieren. Diese Laufvariable kann benutzt werden, um den Abbruch, bzw. die Weiterführung der Schleife zu steuern. Eine Laufvariable muss vor der Schleife korrekt initialisiert werden und in der Schleife drin mit der gewünschten Schrittweite, z.B. 1, erhöht, bzw. erniedrigt werden: $Variable=1 #<--Laufvariable While ($Variable -le 10) { $Variable $Variable++ } Bei der folgenden Vereinfachung – der Zählschleife - wird diese Laufvariable ($Variable) explizit verwendet und kann in der Deklaration gesteuert werden. 5.3.5 For Zähl-Schleife mit Laufvariable Befehle in definierter Anzahl ausführen. In der FOR-Klammer werden zuerst der INITIATOR, dann eine WIEDERHOLBEDINGUNG und ein ITERATOR (= Schrittweite pro Durchgang) definiert. For ($Variable=1; $Variable -le 10; $Variable++){ $Variable Struktogramm } FOR $Vari able = 1 TO 10 STEP 1 ... $Variable Hinweis: Die Ausführung erfolgt genau gleich wie die zuvor beschriebene While-Schleife mit Laufvariable!

Technische Berufsschule Zürich Informationstechnik Modul 403 Strukturiert programmieren mit WINDOWS PowerShell Version 2.5 KEL 25/34 5.3.6 Endlosschleife mit Abbruch (Break) Jede Schleife kann mit dem Befehl Break abgebrochen werden. $var=0 while ($true) { $var++ if ($var -ge 5) { break } write-host $var } 5.3.7 Übung: Doppelschleife Programmieren Sie folgendes Script nach und untersuchen Sie die Ausgabe! • Weshalb entsteht die Dreiecksform? • Wo ist der springende Programmcodeteil, der die Dreiecksform erzeugt (anstatt Viereck)? # Initialisierung Variablen & Konstanten [int]$intvert = read-host \"Geben Sie ein Zahl ein (5-20)\" [string]$sterne = \"\" # Äussere Schleife for ($v=1; $v -le $intvert; $v++) { # Innere Schleife for ($h=1; $h -le $v; $h++) { $sterne += \"*\" #Ein Stern dzufügen } write $sterne $sterne = \"\" }

Technische Berufsschule Zürich Informationstechnik Modul 403 Strukturiert programmieren mit WINDOWS PowerShell Version 2.5 KEL 26/34 6 Fehlermeldungen und Debugging (KR T2, T1) Es gibt verschiedene Arten und Kategorien von Fehlern. Folgend eine nicht abschliessende Liste: ¡ Codierfehler ¡ Logikfehler (z. B. bei Entscheidungen) ¡ Strukturfehler (z. B. bei Iterationen) ¡ Entwurfsfehler (z.B. falsches Design) ¡ Datenfehler (z. B. char/integer; Array falsch definiert; Jahr 2000 Problematik) ¡ Umsetzungsfehler (von Spezifikation ins Programm) ¡ Oberflächenfehler (bei GUI oder sonstiger Benutzerinteraktion) ¡ ... Obige Fehler müssen durch geeignete Tests und/oder Debugging erkannt und anschliessend aus dem Programmcode eliminiert werden. Zwei Arten von Fehlern erzeugen im SW-Entwicklungsprozess einen Abbruch und müssen des- halb vorrangig behandelt werden. 6.1 Syntax-Fehler Syntaxfehler sind Verstöße gegen die Satzbauregeln der PowerShell-Sprache. Programme mit Syntaxfehlern werden vom PowerShell-Interpreter zurückgewiesen. Syntaxfehler werden vom Parser in der Analysephase des Interpreterlaufs erkannt, genauer in der syntaktischen Analyse. Dabei muss der Parser nicht nur erkennen, dass der analysierte Quellcode nicht der formalen Grammatik der Programmiersprache entspricht, sondern auch eine verständli- che Fehlermeldung ausgeben. 6.2 Laufzeit-Fehler und Fehlermeldungen in der Konsole Da sich nicht alle Eigenschaften von PowerShell durch kontextfreie Grammatiken beschreiben lassen, werden manche Fehler, z. B. Verstösse gegen die Typregeln, auch erst in der semanti- schen Analyse vom Interpreter erkannt. Denkfehler im Programm lassen sich zur Übersetzungszeit gar nicht erkennen; Compiler fügen dort jedoch häufig Prüfcode ein, der zu einem Laufzeitfehler erst während der Programmausfüh- rung führt. Ein syntaktisch korrektes Programm kann also zu Laufzeitfehlern führen, wenn es semantische Fehler enthält. Im Gegensatz dazu lassen sich semantische Fehler, also Fehler in der beabsichtig- ten Bedeutung eines Programmtextes, überhaupt nicht maschinell erkennen. 5 Fehler werden beim PowerShell bei der Ausführung angezeigt. Da jede Zeile interpretiert wird, kann es sein, dass eine fehlerhafte Zeile angezeigt wird und der Programmcode trotzdem mit der nächsten Zeile weiterfährt (was logischerweise nicht unbedingt zum gewünschten Erfolg führt). Die Fehlermeldungen in der PowerShell Konsole sind nach einem bestimmten Muster aufgebaut und helfen bei der Fehlersuche. Folgend ein Beispiel mit Erklärungen dazu: 5 Lesen Sie im Internet den Unterscheid zwischen Interpreter und Compiler nach!

Technische Berufsschule Zürich Informationstechnik Modul 403 Strukturiert programmieren mit WINDOWS PowerShell Version 2.5 KEL 27/34 1) Tipp vor dem Programmstart: Führen Sie CLS in der WPS-Konsole aus, um das Fenster von alten Fehlermeldungen zu befreien! 2) Fehlermeldungen erscheinen standard mässig rot im Konsolenfenster! (Zurück scrollen!) 3) Die Fehlermeldung beginnt mit dem als falsch erkannten Programmtext (hier Get-Inpu). 4) Nach dem Doppelpunkt wird ein Erklärungstext zum Fehler ausgegeben. 5) Dann folgt die Auflistung des Script-Pfades und –Namens 6) Nach dem Doppelpunkt wird die Fehlerzeile und Zeichen- position angegeben: 24. Zei- le, 9.Stelle 7) Die Zeile wird angegeben mit dem genauen Fehlerort (Wel- lenlinie) 8) Die Fehlerkategorie und der Fehlercode werden protokol- liert. (à.Net Konstanten) 9) Weitere Zeilen werden (wenn möglich) ausgeführt à Ok Fehler auslesen aus den automatischen Variablen: $?: true wenn letzter Befehl korrekt ausgeführt wurde, false wenn nicht $error: gibt letzte Fehlernummer zurück. 0 für keine Fehler! 6.3 Debugging mit der ISE Der Ablauf eines Script-Programmes wird mit den Einträgen im Menü „Debuggen“ (1) oder besser mit folgenden Funktionstasten gesteuert: • F9: Setzt, bzw. löscht in der markierten Zeile einen Breakpoint (2) • F5: Startet das Script bis zum Breakpoint, bzw. führt weiter aus nach einem Breakpoint. Wenn das Script auf einen Breakpoint trifft, wird dies mit einem hellblauen Hinweistext in der Konsole bekanntgegeben. In der Konsole könnte man nun Cmdlets absetzen, um den aktuellen Status abzufragen. Auch könnten so Variablen geändert werden ... • Shift-F5: Stoppt das Script und beendet den Debugging-Modus. • F10: Einzelschrittausführung (Step Over) ohne in eine Funktion hineinzuspringen. Die ak- tuelle Zeile, die nun als nächstes ausgeführt wird, ist gelb markiert. (3) • F11: Einzelschrittausführung (Step Into) wobei in eine Funktion hineingesprungen wird. • Shift-F11: Einzelschrittausführung (Step Out) wobei aus der Funktion herausgesprungen wird. Während eines Breakpoints können die Variablennamen mit der Maus überfahren werden, und ein Hinweistext gibt dessen Inhalt aus. (4) Siehe auch Add-On „Variablen Explorer“. Weitere Tipps (Englisch): http://blogs.msdn.com/b/PowerShell/archive/2009/01/19/debugging-PowerShell-script-using-the- ise-editor.aspx http://blogs.msdn.com/cfs-filesystemfile.ashx/__key/communityserver-components- postattachments/00-09-34-09-71/debugger.png

Technische Berufsschule Zürich Informationstechnik Modul 403 Strukturiert programmieren mit WINDOWS PowerShell Version 2.5 KEL 28/34 7 Standardfunktionen (KR I3, I4, D4) PowerShell bietet zur Programmierung von verschieden Aufgaben sog. Standardfunktionen aus der .NET Bibliothek an. Viele dieser Funktionen sind sog. Methoden von Datentypen, bzw. Objek- ten. Siehe dazu mehr in den Modulen 404 und 122 . Folgend sind einige Funktionen und Cmdlets zusammengestellt. Siehe auch Kap. 5.4.2. 7.1 Zähl-Funktionen Um gewisse Daten zu zählen gibt es da Cmdlet measure-Object und diverse Methoden. Folgend einige Beispiele. Objektsammlungen mit measure-Object auswerten: (auch Mittel-, Maximal- und Minimalwerte, Summe lassen sich berechnen) Get-process * | measure-Object Get-ChildItem -Filter *.txt | Measure-Object -Property length -Maximum -Minimum - Average –Sum Get-ChildItem -Filter *.txt | Measure-Object -Property length -Maximum -Minimum - Average -Sum | format count, @{\"Label\"=\"average size(KB)\";\"Expression\"={($_.average/1KB).tostring(0)}} Möchte man ganz einfach die Zahl der Zeichen, Wörter und Zeilen einer Textdatei ermitteln, dann kombiniert man get-content mit measure-object: Get-Content mydate.cmd | Measure-Object -line -char –word -IgnoreWhiteSPace Anzahl Elemente zählen, die in der Objektvariable drin gespeichert sind: $b.Count() Anzahl Dateien zählen, die ab dem angegebenen Ordner abgespeichert sind: (Get-ChildItem C:\\User\\Name -Recurse –force).count() 7.2 String-Funktionen (KR D4) Das Bearbeiten von Strings gehört zu den häufigsten Operationen in Script-Sprachen. Während althergebrachte Tools wie Batch-Dateien und VBScript solche Aufgaben oft nur umständlich bewäl- tigen können, bietet PowerShell das ganze Inventar an Funktionen, die man etwa von Javascript oder PHP kennt. Wesentlich zum Verständnis von String-Manipulationen in PowerShell ist die Tatsache, dass es sich bei Zeichenketten immer um Objekte handelt - und zwar unabhängig davon, ob sie wörtlich oder als Variablen vorliegen. Daher stellen die Methoden der String-Objekte die meisten benötig- ten Funktionen zur Verfügung. Diese kann man wie gewohnt durch das Cmdlet Get-Member an- zeigen lassen: \"Hallo Welt\" | Get-Member

Technische Berufsschule Zürich Informationstechnik Modul 403 Strukturiert programmieren mit WINDOWS PowerShell Version 2.5 KEL 29/34 Das Ergebnis besteht aus einer beachtlichen Liste: Clone CompareTo Contains CopyTo EndsWith Equals GetEnumerator GetHashCode GetType GetTypeCode IndexOf IndexOfAny Insert IsNormalized LastIndexOf LastIndexOfAny Normalize PadLeft PadRight Remove Replace Split StartsWith Substring ToBoolean ToByte ToChar ToCharArray ToDateTime ToDecimal ToDouble ToInt16 ToInt32 ToInt64 ToLower ToLowerInvariant ToSByte ToSingle ToString ToType ToUInt16 ToUInt32 ToUInt64 ToUpper ToUpperInvariant Trim TrimEnd TrimStart 7.2.1 Zeichenketten zusammenfügen Einige Aufgaben erfordern darüber hinaus jedoch den Einsatz von Operatoren. Dazu zählt man- gels einer concat-Funktion etwa das Verketten von Strings, was die Sache aber letztlich einfacher macht. So kann man zwei oder mehrere Zeichenketten schlicht mit dem Plus-Operator zusammen- fügen: $h = \"Hallo\" $w = \"Welt\" $h + \" \" + $w Alternativ kann man einfach die beiden Strings innerhalb von Anführungszeichen expandieren: \"$h $w\" Das Leerzeichen in diesem Beispiel gewährleistet, dass die beiden Wörter nicht zusammenkleben. Man könnte stattdessen ein beliebiges anderes Trennzeichen einsetzen. Dieses Verfahren eignet sich auch, um die Elemente eines String-Arrays zu konkatenieren: $st = @(\"Hallo Welt\", \"Hello World\") \"$st\" In diesem Fall fügt PowerShell automatisch ein Leerzeichen zwischen die verketteten Elemente des Arrays ein. Als weitere Option für das Zusammenfügen von Zeichenketten bietet sich der join-Operator an, dessen Verwendung aber nicht gerade intuitiv ist. So steht er normal vor den Strings, außer man möchte diese nach dem Verschmelzen durch einen Separator trennen: -join($h,$w) Ist man in diesem Beispiel nicht mit dem Ergebnis \"HalloWelt\" einverstanden und möchte ein Leer- zeichen zwischen den beiden Wörtern, dann erfolgt der Aufruf in dieser Form: $h,$w -join \" \" 7.2.2 Strings zerlegen Für den umgekehrten Vorgang, nämlich das Auftrennen von Zeichenketten, hat man die Wahl zwi- schen der Split-Methode und dem split-Operator. Erstere ist einfacher gestrickt und erlaubt nur die Verwendung von expliziten Separatoren, während der Operator auch reguläre Ausdrücke zulässt.

Technische Berufsschule Zürich Informationstechnik Modul 403 Strukturiert programmieren mit WINDOWS PowerShell Version 2.5 KEL 30/34 So würde (\"Hallo Welt\").split(\"ll\"\" \") Die Zeichenkette am Doppel-l und am Leerzeichen zerteilen, wobei die Trennzeichen dabei auf der Strecke bleiben. Das Ergebnis liegt als Array vor, wobei man mit Hilfe eines weiteren Parameters von Split festlegen kann, in wie viele Elemente der String maximal zerlegt wird. Hier wären es 2: (\"Hallo Welt\").split(\"ll\"\" \", 2) 7.2.3 Substring extrahieren Einem ähnlichen Anliegen wie Split dient die Methode Substring, weil sie einen Teil der Zeichen- kette herauslösen kann. Dies erfolgt aber nicht anhand von Trennzeichen, sondern wie in anderen Sprachen über Positionsangaben: (\"Hallo Welt\").Substring(2,5) Dieser Aufruf ergibt die Zeichenkette \"llo W\", also den Abschnitt beginnend beim 3. Zeichen (die Zählung beginnt bei 0!) und einer Länge von 5. Die komplementäre Methode zu Substring ist Remove. Sie erzeugt einen Ausschnitt von Zeichen- ketten, indem sie den angegebenen Bereich entfernt: (\"Hallo Welt\").Remove(2,3) In diesem Beispiel würde \"all\" aus \"Hallo Welt\" gelöscht. Möchte man führende und/oder abschließende Leerzeichen eliminieren, dann kann man das mit TrimStart, TrimEnd oder Trim tun. 7.2.4 Zeichen suchen und ersetzen PowerShell kennt eine ganze Reihe von Techniken, um Zeichen oder Substrings zu finden und zu ersetzen. Auch hier stehen für anspruchsvollere Aufgabe reguläre Ausdrücke zur Verfügung, die sich zusammen mit den Operatoren -match oder -replace einsetzen lassen. Darüber hinaus eignen sich gleich mehrere Methoden des String-Objekts für diese Aufgabe, wobei natürlich jede von ihnen einem etwas anderen Zweck dient. So handelt es sich bei replace() um die simplere Variante zum Operator, die keine regulären Ausdrücke zulässt: (\"Hallo Welt\").Replace(\"Hallo\",\"Neue\") Ein gleichnamiges Gegenstück zu -match existiert nicht, dafür bietet PowerShell gleich mehrere Methoden, die sich auf bestimmte Formen der Suche spezialisieren. So ermitteln etwa StartsWith und EndsWith, ob eine Zeichenkette mit einem bestimmten Zeichen oder String beginnt bzw. en- det. Contains wiederum gibt Aufschluss darüber, ob sie eine bestimmte Zeichenfolge enthält: (\"Hallo Welt\").Contains(\"ll\") liefert als Ergebnis den Wert TRUE. Um die Position eines Zeichens oder Substrings zu ermitteln, steht IndexOf zur Verfügung: (\"Hallo Welt\").IndexOf(\"ll\") Auch hier ist daran zu denken, dass die Zählung für das erste Zeichen bei 0 beginnt. 7.2.5 Zeichenketten vergleichen Grundsätzlich lassen sich Unterschiede zwischen Strings über jene Vergleichsoperatoren ermit- teln, die auch für nummerische Werte verwendet werden. Dazu zählen primär -eq und -ne. Hinzu kommt -like, das Wildcards akzeptiert.

Technische Berufsschule Zürich Informationstechnik Modul 403 Strukturiert programmieren mit WINDOWS PowerShell Version 2.5 KEL 31/34 Nicht genug damit, String-Objekte bieten auch dafür noch eigene Methoden an. Es handelt sich dabei um CompareTo und um Equals. Ersteres gibt den Wert 1 zurück, wenn die erste Zeichenket- te in der Sortierreihenfolge zuerst kommt, und -1, wenn es umgekehrt ist. Bei Gleichheit liefert es 0, so dass CompareTo ohne weiteres die Methode Equals ersetzen kann: (\"Hallo Welt\").CompareTo($h + \" \" + $w) Nachdem $h den Wert \"Hallo\" und $w \"Welt\" enthält, ist das Ergebnis in diesem Beispiel 0. Der äquivalente Aufruf von Equals mit (\"Hallo Welt\").Equals($h + \" \" + $w) ergibt dagegen TRUE. Weitere Beispiele: \"abc\".ToUpper() liefert \"ABC\". $nl = [System.Environment]::NewLine erzeugt eine Neue Zeile bei der Ausgabe der Variable\". Links: http://msdn.microsoft.com/de-ch/de/library/system.string%28v=vs.110%29.aspx 7.3 DateTime-Funktionen Ein oft benutzter Datentyp ist DateTime. In einer DateTime.Variable lassen sich Zeit- oder Da- tumswerte – oder beides – abspeichern und verarbeiten. Da dieser Typ als Objekt abgelegt wird, kann man einfach auf dessen Methoden (Aktionen) zugreifen und einige Probleme damit lösen! Da ein Datum immer Ortsabhängig angegeben werden muss, müssen wir bei der Eingabe immer über das ortssensitive Cmdlet Get-Date operieren: Get-Date –format yyyy $heute = Get-Date \"Day: \" + $heute.Day \"Month: \" + $heute.Month \"Year: \" + $heute.Year \"Hour: \" + $heute.Hour \"Minute: \" + $heute.Minute \"Second: \" + $heute.Second Die konkreten Einstellungen sind hiermit ersichtlich: $info = new-object system.globalization.datetimeformatinfo $dn = $info.DayNames $dn $mn = $info.MonthNames $mn

Technische Berufsschule Zürich Informationstechnik Modul 403 Strukturiert programmieren mit WINDOWS PowerShell Version 2.5 KEL 32/34 Ein konkreter Zeitpunkt (mit Datum) kann mittels einem String eingegeben werden: [DateTime]$Zeitpunkt = Get-Date \"12.3.2015 15:33\" Write-Host $Zeitpunkt à 12.03.2015 15:33:00 Eine konkrete Uhrzeit (mit heutigem Datum): [DateTime]$Zeit = Get-Date \"15:33\" Write-Host $Zeit à tt.mm.yyyy 15:33:00 Ein konkretes Datum (Zeit = 00:00:00): [DateTime]$Datum = Get-Date \"12.3.2015\" Write-Host $Datum à 12.03.2015 00:00:00 Alle Eigenschaften und Methoden anzeigen lassen: (Punkt-Operator oder CTL-SPACE) Eigenschaften auslesen: $Zeitpunkt.DayOfYear à 71 $Zeitpunkt.TimeOfDay à Tabelle mit allen Werten Methoden anwenden: Rechnen: $Zeitpunkt.AddDay(2) à 14.03.2015 $Zeitpunkt.AddDay(-2) à 10.03.2015 ([datetime] \"1.2.2006\" - [datetime]\"1.1.2006\").TotalDays Eigene Funktion: function tillXmas () { $now = [DateTime]::Now [Datetime](\"25.12.\" + [string]$now.Year) - $Now } Konvertieren: $Zeitpunkt.ToString() à \"12.03.2015 15:33\" $Zeitpunkt.ToOADate() à 42075,6479166667 (zum Vergleichen!) $Zeitpunkt.ToShortTimeString() à \"15:33\" Siehe auch: http://www.msxfaq.de/code/PowerShell/psdatetime.htm

Technische Berufsschule Zürich Informationstechnik Modul 403 Strukturiert programmieren mit WINDOWS PowerShell Version 2.5 KEL 33/34 7.4 Robuste Eingabe von Daten (KR I3 I4) Wie in Kapitel 3.5 beschrieben, ist es notwendig eine Eingabe zuerst in eine String-Variable zwi- schen zu speichern, damit falsche Eingaben nicht zu einem Laufzeitfehler führen. Danach sollte eine Prüfung des Inhalts erfolgen. Bei korrektem Inhalt (Bereich und Art) wird der Inhalt via Cast-Operator in eine geeignet typisierte Variable umgespeichert und verarbeitet. Bei inkorrektem Inhalt sollte eine möglichst genaue Fehlermeldung erfolgen und die Eingabe wie- derholt werden. Oft muss unterschieden werden, ob der Inhalt numerisch ist oder nicht. Hierzu können wir im eige- nen Programm folgende Funktion erstellen: # Testet Stringvariable auf nummerischen Inhalt function isNumeric ($x) try { 0 + $x | Out-Null return $true } catch { return $false } } Falsches Beispiel, das bei der Eingabe von Buchstaben zu einem Laufzeitfehler führt: ... [int]$intZahl = read-host \"Geben Sie die Fakultätszahl ein (1 - 11)\" ... Korrektes Beispiel mit robuster Eingabe: ... [boolean]$ok = $false # Merker zurücksetzen # Robuste Eingabe der Fakultätszahl Do { # Wiederholung bei Falscheingaben [sting]$strZahl = read-host \"Geben Sie die Fakultätszahl ein (1 - 11)\" if ($strZahl -eq \"\") { # KEINE Eingabe bedeutet Abbruch # Warnung: write-host \"ABBRUCH: Es wurde keine Eingabe gemacht!\" return # Exit Script!! }elseif ( isnumeric( $strZahl ) ) { # Umwandlung String --> Int OHNE Laufzeitfehler [int]$intZahl = [int]$strZahl $ok = $true # Alles korrekt: Merker setzen }else { # Konkrete Fehlermeldung: Write-host \"EINGABEFEHLER: Bitte eine ZAHL (1 – 11) eingeben!\" } } Until ($ok) # Nur weiter, wenn Eingabe und Konversion korrekt sind ... KEL ¯\\_(ツ)_/¯

Technische Berufsschule Zürich Informationstechnik Modul 403 Strukturiert programmieren mit WINDOWS PowerShell Version 2.5 KEL 34/34