Powershell-Basics

1. Lassen sie sich alle cmd-Let's mit dem Verb-Namen "Get" anzeigen.
2. Zeigen sie den Hilfetext zum cmd-let Get-Process an
3. Wie heisst der komplette Befehl, um sich den Prozess mit der Prozess-ID 7788 anzeigen zu lassen?
4. Erstellen sie auf ihrem Desktop ein Unterverzeichnis mit dem Namen "Muster". Dieses Verzeichnis befüllen sie mit ein paar Dateien nach Wahl (Texte, Bilder, Audio etc.). Zwei davon müssen Textdateien mit der Endung ".txt" sein. Erstellen Sie im Verzeichnis "Muster" ein weiteres Unterverzeichnis mit dem Namen "Texte". In diesem Verzeichis erstellen sie ein weiteres Textfile mit dem Namen "hallo.txt". Verlangt ist nun ein WPS-Skript, der ein Listing über alle Textfiles (.txt) ab dem Verzeichnis "Muster" inklusive den darunterliegenden erstellt. Das Resultat soll in eine Datei mit der Bezeichnung "MusterListing.txt" geschrieben werden. Der Skript soll ausschliesslich relative Pfade verwenden.

1. get-command get*
2. get-help get-process
3. get-process -id 7788

4. Get-ChildItem . *.txt -Recurse > MusterListing.txt
   Get-ChildItem * -Recurse -Include *.txt >> MusterListing.txt
   

1. Hilfe anfordern: Zeigen sie sich zu dem CmdLet "get-childitem" die Hilfe und die Beispiele (Examples) an.
2. Skript ausführen: Sie erhalten den folgenden Powershell-Skript:

   #Titel: Mein erster Powershell-Skript
   #Autor: Felix Muster
   #Datum: 3.3.2020
   set-strictmode -version latest  # Codierungsregeln
   cls                             # Konsole leeren
   write-host "Hello World!"
   

   • Kopieren sie den folgenden Powershell-Skript in den Skriptbereich der Powershell-ISE. (Oberer, weisser Bereich)
   • Speichern sie diesen Skript auf ihrem Home-Verzeichnis unter dem Namen hello.ps1
   • Führen sie den Skript innerhalb der Powershell ISE aus. (Unterer blauer Bereich bzw. Powershell-Konsole)
   • Wechseln sie in das cmd (Eingabeaufforderung) und starten sie den Skript erneut.
   • Notieren sie sich ihre Beobachtungen.

1. Hilfe anfordern:
   • get-help get-childitem
   • get-help get-childitem -examples
2. Skript ausführen:
   • In der Powershell ISE das grüne Dreieck im Menübereich anklicken oder die Funktionstaste 5 betätigen.
   • CMD > powershell.exe -command .\hello.ps1

Zahlen zusammenzählen:
Der Benutzer gibt eine positive, ganze Zahl $x ein. Danach werden die ganzen Zahlen ab 0 bis $x zusammengezählt und das Resultat ausgegeben. Bsp.: Eingabe 6 → 1+2+3+4+5+6=21

Zahlen zusammenzählen:

# Autor: ARJ
# Datum: 8.1.2021
set-psdebug -strict  #Programmiermodus einschraenken
cls
[int]$x=0  #UserZahl
[int]$i=1  #Schleifenvariable
[int]$r=0  #Resultat
$x = read-host "Pos. Zahl eingeben"
while( $i -le $x)
{
  $r = $r + $i
  $i = $i + 1
}
write-host "Resultat $r"

1. Zahleneingabe prüfen: Der Benutzer gibt eine ganze Zahl zwischen -100 und + 100 ein. Danach wird geprüft, ob die eingegebene Zahl negativ, Null oder positiv ist. Der Befund wird auf der Konsole ausgegeben.

---

2. Verknüpfte Bedingung: Eine Funktion soll nur dann ausgeführt werden, falls Motor 1 nicht eingeschaltet ist, oder Motor 2 nicht eingeschaltet ist, oder beide ausgeschaltet sind. Sofern noch nicht geschehen, erstellen sie das Struktogramm. Danach schreiben sie das erforderliche Powershell-Programm.

---

3. Wer ist älter: Die Geburtsdaten (Dreiteilig als Geburtsjahr [int], Geburtsmonat [int] und Geburtstag [int]) zweier Personen sind gegeben. Stellen sie fest, welche von den beiden Personen die ältere ist.
   (Hinweis: Das Datum MUSS dreiteilig Tag/Monat/Jahr eingelesen werden. Datumsdatentypen sind nicht erlaubt.)
   Sofern noch nicht geschehen, erstellen sie das Struktogramm. Danach schreiben sie das erforderliche Powershell-Programm.

---

4. Schaltjahr bestimmen: Das Programm bzw. der Algorithmus soll bestimmen, ob es sich bei der vom Benutzer eingegebenen Jahreszahl um ein Schaltjahr handelt oder nicht. Für die Bestimmung eines Schaltjahrs gilt die folgende Regel:
   Jedes vierte Jahr ist ein Schaltjahr. Alle hundert Jahre wird diese Regel gebrochen, um kleine Fehler zu korrigieren. Dabei entsteht wiederum ein winziger Fehler, der alle vierhundert Jahre korrigiert wird, indem dann ein vermeintlich ausgefallenes Schaltjahr doch wieder eines ist. Im Februar 2000 tritt genau dieser Fall ein.
   Tipp: Verwenden Sie den Modulo-Operator %. Der Modulo-Operator gibt jeweils den Rest einer Division an. Bsp. 10 % 4 gibt den Wert 2
   Sofern noch nicht geschehen, erstellen sie das Struktogramm. Danach schreiben sie das erforderliche Powershell-Programm.

---

5. Zahlen sortieren:Erstellen Sie das Programm "Zahlen sortieren" anhand des folgenden Struktogramms: Geben Sie die Zahlenreihe in aufsteigender und absteigender Reihenfolge an.

---

1. Zahleneingabe prüfen:

   # Autor: ARJ
   # Datum: 8.1.2021
   set-psdebug -strict  #Programmiermodus einschraenken
   cls                  #Fenster leeren
   [int]$meineZahl=0
   $meineZahl = read-host "Bitte Zahl -100 bis +100 eingeben"
   if( $meineZahl -lt 0)
   { #Beginn Block
     write-host "Zahl negativ"
   } # End Block
   else
   {
     if ( $meineZahl -gt 0)
     {
       write-host "Zahl grösser 0"
     }
     else
     {
       write-host "Zahl ist gleich 0"
     }
   }
   

---

2. Verknüpfte Bedingung:

   #******************* «Verknüpfte Bedingung» ***********************************
   # VERSION: V.1
   # AUTOR:   ARJ
   # DATUM:   7.12.2020
   # ZWECK:   Motoren einschalten (Umgesetzt ist Struktogramm Variante3)
   #******************************************************************************
   # Auf der Konsole ausführen: Set-ExecutionPolicy unrestricted
   set-strictmode -version latest  # Codierungsregeln verschärfen
   #******************* Variablen-Deklaration & Initialisierung ******************
   [string]$meineAntwort = "n"  #Hilfsvariable für die Eingabe
   [bool]$motor1_ON = $false    #Motor-1
   [bool]$motor2_ON = $false    #Motor-2
   #******************* HIER BEGINNT MEIN PROGRAMM *******************************
   cls  # Bildschirm (Konsole) löschen
   #********** EINGABE **************
   $meineAntwort = Read-Host "Motor-1 eingeschaltet? (j/n)"
   if($meineAntwort -eq "j")
   {
     $motor1_ON = $true
   }
   $meineAntwort = Read-Host "Motor-2 eingeschaltet? (j/n)"
   if($meineAntwort -eq "j")
   {
     $motor2_ON = $true
   }
   #********** VERARBEITUNG *********
   if($motor1_ON -and $motor2_ON)                
   {
     write-Host "Funktion nicht ausführen"
   }
   else
   {
     write-Host "Funktion ausführen"
   } 
   #******************* HIER ENDET MEIN PROGRAMM **********************************
   

---

3. Wer ist älter:

   # ******** Wer ist aelter ********
   # Programm-Versionsnummer: 1.0
   # Autor: ARJ
   # Datum: 2. 12. 2019
   # Beschreibung:  Bestimmern, wer von zwei Personen aelter ist
   # Programmiermodus einschraenken
   set-psdebug -strict
   # Variablen-Deklaration/Initialisierung
   [int]$A_Jahr = 0  # Jahrgang Person A
   [int]$A_Monat = 0 # Geburtsmonat Person A 1=Januar 12=Dezember
   [int]$A_Tag = 0   # Geburtstag Person A 0..31
   [int]$B_Jahr = 0  # Jahrgang Person B
   [int]$B_Monat = 0 # Geburtsmonat Person B 1=Januar 12=Dezember
   [int]$B_Tag = 0   # Geburtstag Person B 1..31
   cls  # ClearScreen
   # *** EINGABE Person A ***
   $A_Jahr  = Read-Host "Erste Person -> Geburtsjahr (4-stellig): "
   $A_Monat = Read-Host "Erste Person -> Geburtsmonat (1=Januar ... 12=Dezember): "
   $A_Tag   = Read-Host "Erste Person -> Geburtstag (1 ... 31): "
   # *** EINGABE Person B ***
   $B_Jahr  = Read-Host "Zweite Person -> Geburtsjahr (4-stellig): "
   $B_Monat = Read-Host "Zweite Person -> Geburtsmonat (1=Januar ... 12=Dezember): "
   $B_Tag   = Read-Host "Zweite Person -> Geburtstag (1 ... 31): "
   # *** VERARBEITUNG + Ausgabe ***
   if ($A_Jahr -gt $B_Jahr)
   {
     Write-Host "Die zweite Person ist aelter als die erste!"
   }
   else
   {
     if ($A_Jahr -lt $B_Jahr)
     {
       Write-Host "Die erste Person ist aelter als die zweite!"
     }
     else
     {
       if ($A_Monat -gt $B_Monat)
       {
         Write-Host "Die zweite Person ist aelter als die erste!"
       }
       else
       {
         if ($A_Monat -lt $B_Monat)
         {
           Write-Host "Die erste Person ist aelter als die zweite!"
         }
         else
         {
           if ($A_Tag -gt $B_Tag)
           {
             Write-Host "Die zweite Person ist aelter als die erste!"
           }
           else
           {
             if ($A_Tag -lt $B_Tag)
             {
             Write-Host "Die erste Person ist aelter als die zweite!"
             }
             else
             {
               Write-Host "Die erste Person ist gleich alt wie die zweite!"
             }
           }
         }
       }
     }
   }
   # ******** Hier endet das Programm ********
   

---

4. Schaltjahr bestimmen:

   # ******** Schaltjahr ********
   # Programm-Versionsnummer: 1.0
   # Autor: ARJ
   # Datum: 2. 12. 2019
   # Beschreibung:  Schaltjahr bestimmen
   # Programmiermodus einschraenken
   set-psdebug -strict
   # Variablen-Deklaration/Initialisierung
   [int]$meinJahr = 0 # Zu ueberpruefendes Jahr
   cls # ClearScreen
   # *** EINGABE ***
   $meinJahr  = Read-Host "Geben sie das Jahr an, von welchem sie ueberpruefen wollen, ob es ein Schaltjahr ist: "
   # *** VERARBEITUNG + Ausgabe ***
   if ( ($meinJahr % 4) -ne 0)
   {
     Write-Host "Das Jahr" $meinJahr "ist kein Schaltjahr!"
   }
   else
   {
     if ( ($meinJahr % 100) -ne 0)
     {
       Write-Host "Das Jahr" $meinJahr "ist ein Schaltjahr!"
     }
     else
     {
       if ( ($meinJahr % 400) -eq 0)
       {
         Write-Host "Das Jahr" $meinJahr "ist ein Schaltjahr!"
       }
       else
       {
         Write-Host "Das Jahr" $meinJahr "ist kein Schaltjahr!"
       }
     }
   }
   # ******** Hier endet das Programm ********
   

---

5. Zahlen sortieren: Naheliegend währe die Idee, das Array mit einem Powershell-Cmd-Let auf diese Art zu sortieren: $arrx = $arrx | sort
   Allerdings soll ein eigener Algoritmus entwickelt und implementieret werden.
   In der folgenden Musterlösung wird nun aber nicht die Umsetzung gemäss dem Struktogramm in der Aufgabenstellung gezeigt, dass sollte nun ja kein Problem mehr darstellen, sondern vielmehr eine etwas raffiniertere und alternative Methode: Mit einem sogenannten Bubble-Sort: (Auf die selbe Weise können fast beliebig lange Zahlenreihen sortiert werden.)
   • Die erste Zahl wird mit der zweiten Zahl verglichen und falls nötig vertauscht.
   • Die zweite Zahl wird mit der dritten Zahl verglichen und falls nötig vertauscht.
   • Um eine allfällig in der Mitte sitzende kleinste Zahl nach links durchzureichen, wird der erste Schritt wiederholt bzw. die erste Zahl wird mit der zweiten Zahl wiederholt verglichen und falls nötig vertauscht.
   • Testen sie den Algorithmus mit verschiedenen Zahlenreihen, wie z.B. 123, 132, 312, 213, 321, 231, 111, 112, 211, 121, 332 etc.

   #Titel: Zahlen sortieren
   #Autor: ARJ
   #Datum: 1.3.2021
   set-strictmode -version latest
   cls
   [int]$i = 0           # Laufvariable
   [int]$x = 0           # Hilfsvariable zm Umkopieren
   [int[]]$arrx = 0,0,0  # Array mit drei Werten
   # ****** Eingabe von drei Zahlen
   for($i=0; $i -lt 3; $i++)
   {
     $arrx[$i] = read-host "Bitte" ($i+1) ". Zahl eingeben"
   }
   # ****** Verarbeitung
   if($arrx[0] -gt $arrx[1]) #Grösseren Wert nach rechts reichen
   {
     $x = $arrx[1]           # Wert zwischenspeicher
     $arrx[1] = $arrx[0]     # Wert umkopieren
     $arrx[0] = $x           # Zwischenspeicher zurückschreiben
   }
   if($arrx[1] -gt $arrx[2]) #Grösseren Wert nach rechts reichen
   {
     $x = $arrx[2]           # Wert zwischenspeicher
     $arrx[2] = $arrx[1]     # Wert umkopieren
     $arrx[1] = $x           # Zwischenspeicher zurückschreiben
   }
   if($arrx[0] -gt $arrx[1]) #Grösseren Wert nach rechts reichen
   {
     $x = $arrx[1]           # Wert zwischenspeicher
     $arrx[1] = $arrx[0]     # Wert umkopieren
     $arrx[0] = $x           # Zwischenspeicher zurückschreiben
   }
   #  ****** Ausgabe der sortierten Reihe
   write-host $arrx
   

---

1. Zeichenkolonne: Der Vorspann des Kinoklassikers The Matrix zeigt wasserfallähnlich unzählige, fallende grüne Buchstaben. Etwas ähnliches soll in diesem Programm erreicht werden, allerdings beschränkt auf eine einzige Kolonne: Der Benutzer gibt mit $k ein, wie hoch diese Kolonne sein soll. Die Kolonne soll sich in unserem Beispiel so darstellen:
   X, dann 2 mal I, dann wiederholt sich das Ganze bis zur Höhe $k
   Bsp:
   Eingabe Kolonne $k → 7
   Ergibt die folgende Ausgabe: (in der vertikalen Ebene)
   X → I → I → X → I → I → X

---

2. Zufallszahl erraten V1: Der Benutzer soll eine vom Computer generierte Zufallszahl (Random Number) zwischen 100 und 999 erraten. Der Computer gibt ihm dazu folgende Hinweise:
   • Kalt: Wenn der Benutzer um mehr als 100 daneben liegt
   • Warm: Wenn der Benutzer zwischen 100 und 51 daneben liegt
   • Heiss: Wenn der Benutzer bis zu 50 daneben liegt
   • Bingo: Bei einem Treffer
   Zusatzaufgabe: Das Spiel soll, wenn vom Benutzer gewünscht, wiederholt werden. Ausserdem soll das Ratespiel zu jedem Zeitpunkt vom Benutzer abgebrochen werden können.
   Sofern noch nicht geschehen, erstellen sie das Struktogramm. Danach schreiben sie das erforderliche Powershell-Programm.

---

3. Lichtkubus: Es soll ein dreidimensionales Feld entsprechend eingefärbt werden. Hinweis zum Koordinatensystem: Die unterste Kugel links hat die Position x=0, y=0, z=0.
   Sofern noch nicht geschehen, erstellen sie das Struktogramm. Danach schreiben sie das erforderliche Powershell-Programm für diese konkrete Lichtansteuerung.
   

---

4. Zufallszahl erraten V2: Der Computer würfelt eine Zahl zwischen 1 und 100, die der User anschliessend erraten soll. Jeder Tipp wird mit der Meldung "Zahl ist grösser" ode "Zahl ist kleiner" quittiert. Nach 10 erfolglosen Rateversuche kann der User entscheiden, ob er ein neues Spiel wünscht.
   Sofern noch nicht geschehen, erstellen sie das Struktogramm. Danach schreiben sie das erforderliche Powershell-Programm.

---

5. Fibonacci-Folge: Die Fibonacci-Folge ist die unendliche Folge von natürlichen Zahlen, die ursprünglich mit zweimal der Zahl 1 beginnt oder in der modernen Schreibweise zusätzlich mit einer führenden Zahl 0 versehen ist. Im Anschluss ergibt jeweils die Summe zweier aufeinanderfolgender Zahlen die unmittelbar danach folgende Zahl: Realisieren sie nun das entsprechende Programm wie folgt:
   • Der Benutzer gibt an, wie viele Fibonacci-Zahlen berechnet bzw. angezeigt werden sollen.
   • Die Berechnung der Zahlen soll mit einer Iteration gelöst werden.
   • Tipp: Zur Berechnung ein Array verwenden. Dabei aber eine allfällige Array-Bereichsüberschreitung beachten.

---

6. Tannenbaum zeichnen: Der Benutzer gibt als Zahl ein, wie hoch der Tannenbaum (Anzahl Zeilen ab 1 bis 10) werden soll. Erstellen bzw. "zeichnen" sie anschliessend diesen Tannenbaum. Benutzen sie im Programmcode dafür ausschliesslich die Iteration "for()". Wie die for-Schleife angewendet wird, erklärt ihnen der Fachbeitrag zu Powershell.

---

7. Taschenrechner:
   • Erstellen Sie einen einfachen Rechner mit den folgenden mathematischen Grundoperationen: + , - , * , / , % (% ist die Module oder Restwertfunktion)
   • Die Benutzereingabe soll nach UPN (Umgekehrte polnische Notation, wie sie bei HP-Taschenrechner Verwendung findet/fand) erfolgen: 1. Zahl , 2. Zahl, Operand
   • Nachdem das Resultat am Bildschirm erschienen ist, hat der User die Wahl, mit dem Buchstaben "X" (für Exit) das Programm zu verlassen oder mit einer weiteren Zahl und Operand die Rechnung fortzusetzen.
   • Die Berechnungen sollen mit doppelter Genauigkeit durchgeführt werden.
   • Die Resultatsausgabe soll mathematisch gerundet auf vier Nachkommastellen angezeigt werden.
   • Lauzeitfehler wie z.B die Division durch Null sollen abgefangen und entsprechend signalisiert werden.
   

---

1. Zeichenkolonne:

   # Autor: ARJ
   # Datum: 8.1.2021
   set-psdebug -strict  #Programmiermodus einschraenken
   cls
   [int]$k=0
   [int]$i=0
   $k = read-host "Höhe eingeben"
   while ($i -lt $k)
   {
     if( $i % 3 -eq 0)
     {
       write-host "X"
     }
     else
     {
       write-host "I"
     }
     $i = $i + 1
   }
   

---

2. Zufallszahl erraten V1:

   # ******** Zahl wuerfeln ********
   # Programm-Versionsnummer: 1.0
   # Autor: ARJ
   # Datum: 2. 12. 2019
   # Beschreibung:  Computer wuerfelt Zufallszahl und User soll sie anschliessend erraten
   # Programmiermodus einschraenken
   set-psdebug -strict
   # Variablen-Deklaration/Initialisierung
   [int]$meineZufallszahl = 0 # Vom Computer zufaellig gewaehlte Zahl
   [int]$meinRateversuch = 0  # Vom User ausgedachte Zahl
   [uint]$meineDifferenz = 0  # Differenzbetrag mit Datentyp Unsigned INT -> Vorzeichenloser INT
   [boolean]$ZahlGefunden = $false #Flag fuer Treffer
   [boolean]$abbrechen = $false    #Flag fuer Programmabbruch
   cls  # ClearScreen
   # *** Vorarbeiten ***
   $meineZufallszahl = Get-Random -Minimum 100 -Maximum 999
   # *** VERARBEITUNG ***
   while ( (-not $ZahlGefunden) -and (-not $abbrechen) )
   {
     Write-Host "Nur fuer Schummler: Der Computer hat" $meineZufallszahl "gewuerfelt ;-)"
     $meinRateversuch  = Read-Host "Welche Zahl hat sich der Computer ausgedacht? (Mit Zahl 0 das Programm abbrechen!) "
     if ( $meinRateversuch -eq 0 )
     {
       $abbrechen = $true
     }
     else
     {
       $meineDifferenz = [Math]::abs($meinRateversuch - $meineZufallszahl)  
       # Hinweis: [Math]::abs -> Absolut- oder Betragswert und somit immer positiv!
       if ( $meineDifferenz -gt 100 )   
       {
         Write-Host "KALT! (Mehr als 100 davon entfernt)" -ForegroundColor Blue -Background white
       }
       else
       {
         if ( $meineDifferenz -gt 50 )
         {
           Write-Host "WARM! (51 bis 100 davon entfernt)" -ForegroundColor green
         }
         else
         {
           if ( $meineDifferenz -eq 0)
           {
             Write-Host "--- BINGO! --- (Zahl gefunden)" -ForegroundColor black -Background white
             $ZahlGefunden = $true
           }
           else
           {
             Write-Host "HEISS! (50 und weniger davon entfernt)" -ForegroundColor red
           }
         }
       }
     }
   }
   
   # Meldung bei Abbruch
   if ( $abbrechen )
   {
     Write-Host "Sie haben das Programm abgebrochen!"
   }
   # ******** Hier endet das Programm ********
   

---

3. Lichtkubus:

   # ******** Lichtkubus **********************************
   # Programm-Versionsnummer: 1.0
   # Autor: ARJ
   # Datum: 8. Dez. 2020
   # Beschreibung:  Rote und cyanfarbene Kugeln zählen
   # Auf der Konsole ausführen: Set-ExecutionPolicy unrestricted 
   # Programmiermodus einschraenken
   set-psdebug -strict
   # Variablen-Deklaration/Initialisierung
   [int]$posX = 0 # Koordinate der Kugel in x-Richtung
   [int]$posY = 0  # Koordinate der Kugel in y-Richtung
   [int]$posZ = 0  # Koordinate der Kugel in z-Richtung
   [int]$AnzKugelnCyan = 0  # Anzahl Kugeln mit der Farbe Cyan
   [int]$AnzKugelnRot = 0  # Anzahl Kugeln mit der Farbe Rot
   cls  # ClearScreen
   # Eingabe-Verarbeitung-Ausgabe
   
   while ($posY -lt 7)
   {
     while ($posZ -lt 7)
     {
       while ($posX -lt 7)
       {
         if ( $posY -eq 3)
         {
           $AnzKugelnRot = $AnzKugelnRot + 1
         }
         else
         {
           if ( $posX -eq 3)
           {
             $AnzKugelnRot = $AnzKugelnRot + 1
           }
           else
           {
             $AnzKugelnCyan = $AnzKugelnCyan + 1
           }
         }
         $posX = $posX + 1
       }
       $posX = 0
       $posZ = $posZ + 1
     }
     $posZ = 0
     $posY = $posY + 1
   }
   
   write-host "Von insgesamt 343 Kugeln sind $AnzKugelnCyan cyan-farben und $AnzKugelnRot rot"
   # ******** Hier endet das Programm ********
   

---

4. Zufallszahl erraten V2:

   # ******** Zahl zwischen 1 und 100 erraten ********
   # Programm-Versionsnummer: 1.0
   # Autor: ARJ
   # Datum: 8. Dez. 2020
   # Beschreibung:  Computer wuerfelt Zufallszahl und User soll sie anschliessend erraten
   # Auf der Konsole ausführen: Set-ExecutionPolicy unrestricted 
   # Programmiermodus einschraenken
   set-psdebug -strict
   # Variablen-Deklaration/Initialisierung
   [int]$ZufallsZahl = 0 # Vom Computer zufaellig gewaehlte Zahl
   [int]$SpielerZahl = 0  # Vom User ausgedachte Zahl
   [int]$AnzVersuche = 0  #Anzahl Rateversuche (max. 10)
   [char]$Weiterspielen = "n"
   cls  # ClearScreen
   # Eingabe-Verarbeitung-Ausgabe
   do
   {
     $AnzVersuche = 1
     $ZufallsZahl = Get-Random -Minimum 1 -Maximum 100
     Write-Host "Nur fuer Schummler: Der Computer hat" $ZufallsZahl "gewuerfelt ;-)"  #Debugging
     do
     {
       do
       {
         $SpielerZahl  = Read-Host "$AnzVersuche. Versuch: Zahl zwischen 1 und 100 eingeben"
       } while ( ($SpielerZahl -lt 1) -or ($SpielerZahl -gt 100) )  # Eingabe zwischen 1 und 100 erzwingen
   
       if($ZufallsZahl -gt $SpielerZahl)
       {
         Write-Host "Zufallszahl ist groesser"
       }
       else
       {
         if($ZufallsZahl -lt $SpielerZahl)
         {
           Write-Host "Zufallszahl ist kleiner"
         }
         else
         {
           Write-Host "Sie haben die Zahl $ZufallsZahl in $AnzVersuche. Versuchen erraten"
           $AnzVersuche = 10 #Damit man die innere Schleife verlässt
         }
       }
       $AnzVersuche = $AnzVersuche + 1
     } while ($AnzVersuche -lt 10)
   
     $Weiterspielen = Read-Host "Weiterspielen? (j oder n)"
   } while ($Weiterspielen -eq "j")
   Write-Host "Sie haben das Programm verlassen."
   # ******** Hier endet das Programm ********
   

---

5. Fibonacci-Folge Variante-A: Mit Hilfsvariablen (Schlepper): (Vorteil dieser Variante: Ohne Array und damit der Gefahr von Array-Bereichsüberschreitung. Dafür müssen die beiden vorangegangenen Berechnungen zwischengespeichert werden.)

   # ******** TITEL: Fibonacci-Folge ********
   # Version: V1.0
   # Autor: ARJ
   # Datum: 29.1.2020
   # Beschreibung: Fibonacci-Folge mit Iteration ohne Array
   # Programmiermodus einschraenken
   set-psdebug -strict
   set-strictmode -version latest
   # Variablen-Deklaration & Initialisierung
   [int]$fff = 0 # Fibonacci-Zahl, jeweils zwei Berechnungen vorher. Der Anfangswert ist 0
   [int]$ff  = 1 # Fibonacci-Zahl, jeweils eine Berechnungen vorher. Der Anfangswert ist 1
   [int]$f   = 1 # Aktuelle Fibonacci-Zahl
   [int]$i   = 0 # Benutzereingabe Anzahl berechneter bzw. angezeigter Fibonacci-Zahlen
   cls # Bildschirm loeschen
   do # Eingabe und Ueberpruefung damit Wertebereich nicht ueberlaufen wird (Data-Overflow bei Integer)
   {
     # Eingabe: Achtung der 47-Wert (0..46) uebersteigt den Wertebereich von Integer
     $i = read-host "Anzahl Fibonacci-Zahlen ab 0 (3 bis 47)" 
   }while ( ($i -lt 3) -or ($i -gt 47) )
   # Ausgabe der ersten beiden Fibonacci-Zahlen
   # Hinweis: Die Option -NoNewLine verhindert den Zeilenumbruch bei write-host
   write-host "Die ersten $i Werte der Fibonacci-Folge lauten:"
   write-host -NoNewline "0 "
   write-host -NoNewline "1 "
   # Ab hier wird berechnet 
   while($i -gt 2)
   {
     $f = $fff + $ff
     write-host -NoNewline "$f "
     $fff = $ff # Letzter Wert in die Variable des vorletzten Wert kopieren
     $ff = $f   # Aktueller Wert in die Variable des letzten Wert kopieren
     $i--       # Zaehlervariable um 1 herunterzaehlen $i = $i -1
   }
   #Programmende
   

   Fibonacci-Folge Variante-B Mit Array: (Vorteil dieser Variante: Alle Fibonacci-Zahlen stehen jederzeit zur Verfügung.)

   # ******** TITEL: Fibonacci-Folge ********
   # Version: V1.0
   # Autor: ARJ
   # Datum: 29.1.2020
   # Beschreibung: Fibonacci-Folge mit Iteration und Array
   # Programmiermodus einschraenken
   set-psdebug -strict
   set-strictmode -version latest
   # Variablen-Deklaration & Initialisierung
   [int[]]$fibonacciFolge = 0,1,0,0,0,0,0,0,0,0,0  # 11Elemente 0..10 Ersten beiden Zahlen (0,1) MUESSEN gegeben sein
   [int]$i = 0
   [int]$z = 0
   cls # Bildschirm loeschen
   do # Eingabe und Ueberpruefung damit Array-Index im gueltigen Bereich ist
   {
     $z = read-host "Anzahl Fibonacci-Zahlen (3 bis 10)" # Eingabe
   }while ( ($z -lt 3) -or ($z -gt 10) )
   write-host "0 Zahl = 0 (OPTIONAL)" # Ausgabe der ersten beiden nicht berechneten Werte
   write-host "1 Zahl = 1"
   for($i=2 ; $i -le $z ; $i++) # Berechnung und Ausgabe der folgenden Fibonacci-Zahlen
   {
     $fibonacciFolge[$i]=$fibonacciFolge[$i-1] + $fibonacciFolge[$i-2]
     write-host $i Zahl "=" $fibonacciFolge[$i]
   }
   #Programmende
   

---

6. Tannenbaum zeichnen: Wie das folgende Bild zeigt, sind bei max. 10 Zeilen in der ersten Zeile die ersten neun Zeichen Leerzeichen, gefolgt von einem ersten *. Pro Zeile reduziert sich der Leerzeichenteil um 1 und der *-Teil erhöht sich um 2.

   # ******** TITEL: X-MAS ********
   # Version: 1.0
   # Autor: ARJ
   # Datum: 10. Januar 2020
   # Beschreibung: Eigenen Weihnachtsbaum erstellen
   # Programmiermodus einschraenken
   set-psdebug -strict
   set-strictmode -version latest
   # Variablen-Deklaration inklusive Initialisierung (Mit Kommentar zum Verwendungszweck!)
   [int]$baumhoehe = 0 # Anzahl Zeilen
   [int]$linkeSeite = 9 # Leerzeichen in Zeile bis Tanne *
   [int]$baumBreite = 1 # Baumbreite in der entsprechenden Zeile
   [int]$i = 0; # Laufvariable
   [int]$j = 0; # Laufvariable
   [string]$tannenZeile = ''
   # *** EINGABE ***
   do
   {
     cls
     $baumhoehe = Read-Host "Gewuenschte Baumhoehe eingeben [1..10]"
   } while ( ($baumhoehe -lt 1) -or ($baumhoehe -gt 10) )
   write-host " " # Leerzeile
   for ($j = $baumhoehe ; $j -gt 0  ; $j = $j-1)
   {
     for ($i = $linkeSeite ; $i -gt 0 ; $i = $i-1)
     {
       $tannenZeile = $tannenZeile + " "
     }
     for ($i = $baumBreite ; $i -gt 0 ; $i = $i-1)
     {
       $tannenZeile = $tannenZeile + "*"
     }
     Write-Host $tannenZeile
     $tannenZeile =''
     $linkeSeite = $linkeSeite - 1
     $baumBreite = $baumBreite + 2
   }
   Write-Host "         *" # Und noch der Baumstamm ;-)
   write-host " " # Leerzeile
   Write-Host "MERRY X-MAS AND A HAPPY NEW YEAR!"
   write-host " " # Leerzeile
   # ******** Hier endet das Programm ********
   

---

7. Taschenrechner:

   # ******** TITEL: UPN-Taschenrechner ********
   # Version: 1.0
   # Autor: ARJ
   # Datum: 8. Januar 2020
   # Beschreibung: Musterloesung UPN-Taschenrechner
   #               Bei UPN werden zuerst die beiden Argumente (Zahlenwerte) eingegeben
   #               und danach erst der Rechnungsoperator.
   # Programmiermodus einschraenken
   set-psdebug -strict
   set-strictmode -version latest
   # Variablen-Deklaration inklusive Initialisierung
   [double]$meinResultat = 0.0 # Eingabe einer ersten Zahl durch den Benutzer und Resultat der Berechnung
   [string]$zweiteEingabe = 0.0 # Eingabe einer zweite Zahl durch den Benutzer als Textzeile
   [double]$zweiteZahl = 0.0 # Zweite Zahl als wirkliche Zahl
   [bool]$zweiteEingabeistZahl = $false # Zur Ueberpruefung ob es sich bei der Eingabe um eine Zahl handelt
   [char]$operator = 'n' # Operator +,-;*,/,% oder x fuer Exit.
   [bool]$operatorOK = $false # Falscher Operator eingegeben
   [bool]$exitOK = $false # Keine weiteren Berechnungen machen
   cls #Bildschirm loeschen
   #Aeussere Schleife (Weitere Berechnung)
   # Erste Zahl eingeben
   $meinResultat = Read-Host "Erster Wert eingeben"
   do
   {
     # Zweite Zahl eingeben
     $zweiteEingabe = Read-Host "Zweiter Wert eingeben (oder x fuer Exit)"
     try
     {
       0 + $zweiteEingabe | Out-Null #Versucht mit der Variable $zweiteEingabe zu rechnen
       $zweiteEingabeistZahl = $true #Hat funktioniert
       $zweiteZahl = [double]$zweiteEingabe
     }
     catch
     {
       $zweiteEingabeistZahl = $false #Hat nicht funktioniert und somit ist $zweiteEingabe keine Zahl
     }
     if ( -not $zweiteEingabeistZahl )
     {
       $exitOK = $true
     }
     else
     {
       do
       {
         #Operator eingeben
         $operator = Read-Host "Operator + , - , * , / , % eingeben (oder beliebieger Buchstabe fuer Abbruch)"
         #Operator untersuchen und Berechnung ausfuehren
         switch ( $operator )
         {
             '+' { # Plus-Operator gewaehlt
                  $meinResultat = $meinResultat + $zweiteZahl
                  write-host "Zwischenresultat" $meinResultat
                  $operatorOK = $true
                }
            '-' { # Minus-Operator gewaehlt
                  $meinResultat = $meinResultat - $zweiteZahl
                  write-host "Zwischenresultat" $meinResultat
                  $operatorOK = $true
                }
            '*' { # Multiplikator-Operator gewaehlt
                  $meinResultat = $meinResultat * $zweiteZahl
                  write-host "Zwischenresultat" $meinResultat
                  $operatorOK = $true
                }
            '/' { # Divisions-Operator gewaehlt
                  # Division durch 0 abfangen
                  if ( $zweiteZahl -ne 0.0 )
                  {
                    $meinResultat = $meinResultat + $zweiteZahl
                    write-host "Zwischenresultat" $meinResultat
                    $operatorOK = $true
                  }
                  else
                  { # Operationszeichen neu eingeben lassen
                    write-host "Division durch 0 ist verboten!"
                    $operatorOK = $false
                  }
                }
            '%' { # Module-Operator (Restwertfunktion) gewaehlt
                  $meinResultat = $meinResultat + $zweiteZahl
                  write-host "Zwischenresultat" $meinResultat
                  $operatorOK = $true
                }
            'x' { # x fuer Exit gewaehlt
                  $operatorOK = $true
                  $exitOK = $true
                }
        default { # Ungueltiges Operationszeichen bzw. Abbruch
                  write-host "Ungueltiges Operationszeichen!"
                  $operatorOK = $false
                }
         } # End-of-switch
       } while ( -not $operatorOK )
     }
   } while ( -not $exitOK )
   write-host "Sie haben die Berechnung abgebrochen!"
   # ******** Hier endet das Programm ********
   

Robuste Benutzereingabe:" Der Benutzer soll eine Zahl von 0 bis 10 eingeben. Anschliessend prüfen sie die Eingabe:

• Wurde anstelle einer Zahl ein Text wie z.B. "zwei" eingegeben? Wenn zutreffend, Ausgabe der Fehlermeldung "Bitte keine Texteingabe!"
• Wurde nur die ENTER-Taste gedrückt? Dann soll die Fehlermeldung "Keine Eingabe gemacht!" angezeigt werden.
• Wurde eine Zahl von 0 bis 10 eingegeben? Wenn nicht: Fehlermeldung "Ihre Zahl ist zu hoch!" oder "Ihre Zahl ist zu tief!"
• War die Eingabe korrekt, geben sie die eingegebene Zahl wie folgt aus: "Sie haben die Zahl <ihrZahl> eingegeben!"
• Tipp: Mit try-catch können Fehler zur Laufzeit abgefangen werden.

Robuste Benutzereingabe:"

# ******** TITEL: Robuste Benutzereingabe ********
# Version: V1.0
# Autor: ARJ
# Datum: 29.1.2020
# Beschreibung: Robuste Benutzereingabe mit try-catch

# Programmiermodus einschraenken
set-psdebug -strict
set-strictmode -version latest

# Variablen-Deklaration & Initialisierung
[string]$meinString = "" # Benutzereingabe
[int]$meineZahl = 0 # Variable fuer die Benutzereingabe als Zahl

cls # Bildschirm loeschen

$meinString = read-host "Bitte eine Zahl von 0 bis 10 eingeben"
if($meinString -eq "")
{
  write-host "Keine Eingabe gemacht!"
}
else
{
  try
  {
    0 + $meinString | Out-Null # Pruefen, ob sich mit $meinString rechnen lässt
    # Das Resultat geht in den Müll, weil wir das ja nicht weiter benötigen: | Out-Null

    # Da es sich nun definitiv um eine Zahl handelt, bedarf es beim Umkopieren in eine Integer-Variable
    # einem Typecast, um das Typenkonzept nicht zu verletzen
    # Typecast bedeutet: Mach aus $meinString einen [int] und weise den der Variable $meineZahl zu (siehe folgende Zeile)
    $meineZahl = [int]$meinString #Wenn sie hier ankommen, laesst sich mit dieser Zahl rechnen
	
    if([int]$meineZahl -lt 0)
    {
      write-host "Ihre Zahl ist zu tief!"
    }
    else
    {
      if($meineZahl -gt 10)
      {
        write-host "Ihre Zahl ist zu hoch!"
      }
      else
      {
        write-host "Sie haben die Zahl $meineZahl eingegeben!"
      }
    }
  }
  catch
  {
    # Die Pseudorechnung hat nicht funktioniert, weil es sich bei $meinString nicht um eine Zahl handelt
    # und wir landen im catch-Bereich. Der Programmabsturz wurde abgefangen eben gecatched.  
    write-host "Bitte keine Texteingabe!"
  }
}
#Programmende

1. Zahl quadrieren: Es soll eine eigene Funktion erstellt werden. Diese Funktion soll eine Zahl quadrieren und als Funktionsrückgabewert an den Aufrufer, in diesem Falls das Hauptprogramm, das Resultat zurückgegeben werden.
2. SinusBerechnen:
   • Erstellen Sie das Programm "SinusBerechnen" anhand des nachfolgenden Struktogramm-Bildes.
   • Der Sinuswert eines bestimmten Winkels lässt sich mit einer Reihenentwicklung näherungsweise berechnen. Umso mehr Durchgänge ausgeführt werden, desto präziser wird das Resultat. (Siehe Formel)
   • Die Reihenentwicklung verlangt eine Winkeleingabe im Bogenmass (360º entsprechen 2π)
   • Die Winkeleingabe soll für den User im Gradmass (0º bis 360º) erfolgen.
   • Die Sinusberechnung (Algorithmus) muss als Funktion gestaltet werden.
   • Nach der Resultatsausgabe soll eine Abfrage mit Weiter [Y/N] eine weitere Berechnung ermöglichen.
   
3. KleinstesGemeinsamesVielfach:
   • Erstellen Sie das Programm "KleinstesGemeinsamesVielfach" anhand des nachfolgenden Struktogramm-Bildes.
   • Mit Modulo ist die Restwertfunktion gemeint.
   • Die kgV-Berechnung muss als Funktion implementiert werden.
   • Nach erfolgter Resultatsausgabe soll der User mit Weiter [Y/N] gefragt werden, ob er eine weitere Berechnung wünscht.
    

1. Zahl quadrieren:

   # Titel: Zahl quadrieren
   # Autor: ARJ
   # Datum: 3.3.2020
   set-psdebug -strict
   # Meine Funktion
   function quadrieren([int] $wert)
   {
     $wert = $wert * $wert
     return $wert
   }
   # Variablendeklaration + Initialisierung
   [int]$zahl1 = 0
   [int]$zahl2 = 0
   [int]$resultat1 = 0
   [int]$resultat2 = 0
   # Hauptprogramm
   cls
   $zahl1 = read-host "Bitte eine Zahl eingeben"
   $zahl2 = read-host "Bitte noch eine Zahl eingeben"
   $resultat1 = quadrieren($zahl1) # Funktionsaufruf
   $resultat2 = quadrieren($zahl2) # Funktionsaufruf
   # Ausgabe
   write-host "Die Zahl $zahl1 quadriert ergibt $resultat1"
   write-host "Die Zahl $zahl2 quadriert ergibt $resultat2"
   

2. SinusBerechnen:

   # ******** TITEL: Sinus berechnen ********
   # Version: 1.0
   # Autor: ARJ
   # Datum: 15. Juli 2021
   # Beschreibung: Musterloesung zu Sinus berechnen
   #               Verwendet wird die Reihenentwicklung fuer die Sinusfunktion.
   #               Der Benutzer kann angeben, wieviele Terme berechnet werden.
   #               Diese Reihenentwicklung verlangt einen Winkel im Bogenmass.
   #               Der Benutzer darf allerdings den Winkel im Gradmass eingeben.
   #               Darum muss zuerst eine Umrechnung vom Gradmass in das Bogenmass durchgefuehrt werden.
   #               Entwicklung des Algorithmus: ARJ
   # Programmiermodus einschraenken
   set-psdebug -strict
   set-strictmode -version latest
   # Variablen-Deklaration und Initialisierung
   [double]$GradMass = 0.0 # Eingabe eines Winkelwertes im Gradmass
   [double]$BogenMass = 0.0 # Eingabe eines Winkelwertes im Gradmass
   [int]$Genauigkeit = 0 # Anzahl Berechnungsdurchgaenge und somit Genauigkeit des Resultats
   [char]$weitereBerechnungen = 'n'
   [double]$dieAbweichung = 0.0 # Abweichung zum tatsaechlichen Sinuswert
   [double]$ResultatSinus = 0.0 #Resultat
   cls #Bildschirm loeschen
   # Es folgt die Function
   function SinusBerechnen([double]$meinWinkelBogen, [int]$anzDurchgaenge)
   { [int]$derzaehler = 0 # Zaehler fuer Anzahl Durchgaenge, lokale Variable
     [double]$diePotenz = 0.0 # Potenzberechnung bzw. Resultat, lokale Variable
     [double]$dieFakultaet = 0.0 # Fakultaetsberechnung bzw. Resultat, lokale Variable
     [double]$derQuotient = 0.0 # Quotientenberechnung bzw. Resultat, lokale Variable
     [double]$meinSinuswert = 0.0 #Resultat, lokale Variable
     # Alle Startwerte fuer die Berechnung setzen (siehe Struktogramm)
     $derzaehler = 2.0
     $meinSinuswert = $meinWinkelBogen
     $diePotenz = $meinWinkelBogen * $meinWinkelBogen * $meinWinkelBogen
     $dieFakultaet = 2.0
     $derQuotient = 1.0 * 2.0 * 3.0
     # Berechnung in einer Schleife gemaess Anzahl Durchgaenge, was die Genauigkeit ausmacht
     while ( $derZaehler -le $anzDurchgaenge )
     {
        if ( ($derzaehler % 2) -eq 0 )
        {
          $meinSinuswert = $meinSinuswert - $diePotenz / $derQuotient
        }
        else
        {
          $meinSinuswert = $meinSinuswert + $diePotenz / $derQuotient
        }
        # Werte fuer den neuen naechsten Durchgang berechnen 
        $dieFakultaet = $dieFakultaet + 2
        $derQuotient = $derQuotient * $dieFakultaet * ($dieFakultaet + 1.0)
        $diePotenz = $diePotenz * $meinWinkelBogen * $meinWinkelBogen
        $derzaehler = $derzaehler + 1
     }
     return $meinSinuswert
   }
   Write-Host "BERECHNUNG DES SINUS MIT EINER REIHENENTWICKLUNG v1.0"
   do
   {
     Write-Host "*****************************************************"
     # Winkelwert eingeben
     $GradMass = Read-Host "Winkel im Gradmass eingeben"
     # Winkel ins Bogenmass umrechnen
     $BogenMass = $meinWinkelGrad / 180 * [math]::pi #[math]::pi ist die Pi-Konstante auf der Math-Library
     # Anzahl Berechnungsdurchgaenge eingeben (Hat Einfluss auf die Genauigkeit des Resultats)
     $Genauigkeit = Read-Host "Genauigkeit [ 1(ungenau) bis 100(sehr genau) ]"
     #Nun folgt der Funktionsaufruf
     $ResultatSinus=SinusBerechnen $BogenMass $Genauigkeit #Funktionsaufruf
     # Ausgabe
     Write-Host "Fuer den" $meinWinkelGrad "Grad Winkel wurde ein Sinuswert von" $ResultatSinus "berechnet"
     $dieAbweichung = $ResultatSinus - [math]::sin($BogenMass) #Korrekter Sinus-Wert berechnen
     $dieAbweichung = [math]::Round($dieAbweichung,6) #Resultat auf 6 Nachkommastellen runden
     Write-Host "Die Abweichung zum korrekten Sinuswert betraegt auf 6 Nachkommastellen gerundet" $dieAbweichung
     $weitereBerechnungen = Read-Host "Weitere Berechnungen? [y/n]"
   } while ( $weitereBerechnungen -eq 'y' )
   Write-Host "*****************************************************"
   Write-Host "Das Programm wurde beendet!"
   # ******** Hier endet das Programm ********
   

3. KleinstesGemeinsamesVielfach: Es existiert noch keine Musterlösung.

1. Erste Erfahrung mit dem Debugger: Bei der Ausführung des folgenden Programms erwarten sie 2 Mal eine Reihe mit "*****". Leider tut es dies nicht. Suchen sie mit dem Debugger den Fehler: (Tipp: Haltepunkt richtig setzen und Variableninhalt überprüfen.)

   # ******** TITEL: Debugger-Uebung 1 ********
   # Version: V1.0
   # Autor: ARJ
   # Datum: 29.1.2020
   # Beschreibung: Den Debugger einsetzen
   # Programmiermodus einschraenken
   set-psdebug -strict
   set-strictmode -version latest
   # Variablen-Deklaration & Initialisierung
   [int]$i = 0
   cls # Bildschirm loeschen
   while($i -le 10)
   {
     if( ($i % 5) -eq 0) # Nach fuenf "*" ... 
     {
       write-host "" # ... auf eine neue Zeile 
     }
     write-host -NoNewline "*" # write-host ohne Zeilenvorschub
     $i++
   }
   write-host ""
   #Programmende
   

2. Debuggen des Skripts "Potenzieren": Das folgende Programm ist eine Powershell-Implementierung (Algorithmus) für die Berechnung die Potenz-Berechnung und weist zwei Fehler auf. Spüren sie diese mit dem Debugger auf und beheben sie die Fehler!
   Berechnugsbeispiele:
   • 3² = 3*3 = 9
   • x⁰ = 1 (x=beliebige Zahl)
   • 2^-3 = 1 / (2*2*2) = 1/8 = 0.125
   Kopieren sie den folgenden Script in ihren Powershell-Scripteditor und suchen sie mit dem Debugger die zwei Fehler! Der Debugger ermöglicht ihnen:
   • Das Programm in Einzelschritten zu durchlaufen.
   • Das Programm bis zu einem Breakpoint vorwärts laufen zu lassen.
     Tipp: Breakpoint an sinnvoller Stelle innerhalb der Iterationen setzen um Schleifendurchgänge zu prüfen.
   • Sich Variableninhalte anzeigen zu lassen.
   Korrigieren sie anschliessend die Fehler und prüfen sie das Programm erneut.

   # ******** TITEL: Potenzieren (Script ist absichtlich Fehlerhaft!) ********
   # Version: 1.0
   # Autor: ARJ
   # Datum: 15. Januar 2020
   # Beschreibung: Potenzieren mit Iteration
   # Fehlerhaftes Programm fuer Debugg-Uebung
   # Programmiermodus einschraenken
   set-psdebug -strict
   set-strictmode -version latest
   # Variablen-Deklaration inklusive Initialisierung auf Null
   [int64]$dieBasis = 0    # Basis der Potenz
   [int64]$derExponent = 0 # Exponent der Potenz
   [int64]$dasResultat = 0 # Resultat der Berechnung
   [int64]$i = 0 # Laufvariable
   cls #Bildschirm loeschen
   # *** EINGABE ***
   $dieBasis = Read-host "Basis"
   $derExponent = Read-host "Exponent"
   $dasResultat = 1
   $i = 0
   if( $derExponent -lt 0) # Exponent negativ
   {
     while($i -ge $derExponent)
     {
       $dasResultat = $dasResultat * $dieBasis
       $i = $i - 1
     }
     # *** AUSGABE ***
     write-host "$dieBasis hoch $derExponent ergibt" (1/$dasResultat)
   }
   else # Exponent positiv
   {
     while($i -lt $derExponent)
     {
       $dasResultat = $dasResultat
       $i = $i + 1
     }
     # *** AUSGABE ***
     write-host "$dieBasis hoch $derExponent ergibt" ($dasResultat)
   }
   # ******** Hier endet das Programm ********
   

3. Debuggen des Skripts "Pi-Berechnung": Das folgende Programm ist eine Powershell-Implementierung (Algorithmus) für die Berechnung der Kreiskonstanten Pi und weist zwei Fehler auf. Spüren sie diese mit dem Debugger auf und beheben sie die Fehler!
   (Diese Formel stammt vom indischen Mathematiker und Astronomen Kelallur Nilakantha Somayaji 1444-1544) Kopieren sie den folgenden Script in ihren Powershell-Scripteditor und suchen sie mit dem Debugger die zwei Fehler. Korrigieren sie anschliessend die Fehler und prüfen sie das Programm erneut.

   # ******** TITEL: Pi berechnen nach Somayaji (Script ist absichtlich fehlerhaft!) ********
   # Version: 1.0
   # Autor: ARJ
   # Datum: 15. Januar 2020
   # Beschreibung: Pi berechnen nach Somayaji
   # Fehlerhaftes Programm fuer Debugg-Uebung
   # Programmiermodus einschraenken
   set-psdebug -strict
   set-strictmode -version latest
   # Variablen-Deklaration inklusive Initialisierung
   [int]$anzTerme = 0 # Anzahl Terme oder Iterationen
   [int]$aktTerm = 1 # Aktueller Term oder Durchgang
   [bool]$numOK = $false # Eingabe ist Zahl
   [double]$thePI = 3.0 # Wert von PI, Initialisiert mit Startwert (Bem.: Pi = 3.141562...)
   [double]$theDivisor = 0.0 # Temporaerer Divisor
   [int]$i # Hilfsvariable, Laufvariable
   # *** EINGABE ***
   do
   {
     try
     { 
       cls #Bildschirm loeschen
       $numOk = $true
       $anzTerme = Read-host "Anzahl Iterationen 1..100"
     } # end try-Part
     catch
     {
       $numOK = $false
     } # end catch-Part
   } until (($anzTerme -ge 1 -and $anzTerme -le 100) -and $numOK)
   # *** VERARBEITUNG ***
   while($aktTerm -le $anzTerme)
   {
     # Divisor berechnen z.B. "3 hoch 3 minus 3"
     $i = 0          # $i zuruecksetzten
     $theDivisor = 0 # $theDivisor zuruecksetzten
     while($i -le 3)
     {
       $theDivisor = $theDivisor * (2 * $aktTerm + 1)
       $i++
     }
     $theDivisor = $theDivisor - (2 * $aktTerm + 1)
     # Ganzer Term berechnen und mit vorangegangenem Resultat verrechnen
     if($aktTerm % 2)  # Aktueller Term ungerade
     {
       $thePI = $thePI + (4 / $theDivisor)
     }
     else  # Aktueller Term gerade
     {
       $thePI = $thePI - (4 / $theDivisor)
     }
     $aktTerm++
   }
   # *** AUSGABE ***
   write-host "Nach $AnzTerme Durchgaengen ergibt die Berechnung fuer Pi $thePi"
   write-host "Die Pi-Konstante in Powershell lautet" ([math]::Pi)
   write-host "Das ergibt eine Abweichung von " ($thePi - [math]::Pi)
   # ******** Hier endet das Programm ********
   

4. Weitere Programme debuggen:
   • Wählen sie einen ihrer bisher erstellten Powershell-Scripte aus. Dieser sollte verschachtelte Iteartionen beinhalten.
   • Starten sie den Debugger
   • Setzen sie geeignete Breakpoints innerhalb einer Iteration
   • Lesen sie die Variablenwerte beim Breakpoint aus
   • Lassen sie das Programm in Einzelschritten ablaufen (Step-by-Step)

Zu diesen Aufgaben existieren keine Musterlösungen.

1. Zeigen sie alle Eigenschaften und Methoden des CmdLets Get-Process an.
2. Starten sie die Applikation notepad.exe und zeigen sie sich danach alle Methoden, Eigenschaften und Aliase) von notepad.exe an.
3. Zeigen sie sich nun ausschliesslich die Methoden von notepad.exe an.
4. Zeigen sie sich nun ausschliesslich die Eigenschaften/Properties von notepad.exe an.
5. Lassen sie sich die Startzeit von "notepad.exe" anzeigen.
6. Versuchen sie die Startzeit von notepad.exe mit der aktuellen Uhrzeit zu überschreiben. Was stellen sie fest?
7. Versuchen sie den notepad.exe Prozess zu beenden. (kill)
8. Lassen sie sich alle Prozesse anzeigen, die "win" im Namen haben.

#Aufgabe 1:
get-process | get-member

#Aufgabe 2:
start-process notepad.exe                             # Programm "notepad.exe" starten
get-process notepad | get-member                      # Methoden, Eigenschaften und Aliase von "notepad.exe" anzeigen
                                                      # Wenn der Prozess notepad.exe nicht gestartet wurde, erscheint eine Fehlermeldung

#Aufgabe 3:
get-process note* | get-member -membertype Properties # Nur die Eigenschaften anzeigen (Tipp: * → Wildcard!)
                                                      # "-membertype AliasProperty" würden nur die Aliase angezeigt
													  
#Aufgabe 4:													  
get-process note* | get-member -membertype Method     # Nur die Methoden anzeigen

#Aufgabe 5:
# Nun werden wir uns Eigenschaften des Prozessobjekts anzeigen lassen
(get-process notepad).starttime                       # Startzeit von "notepad.exe" anzeigen
                                                      # starttime ist eine Eigenschaft des Prozess-Objekts "notepad"
													  
#Aufgabe 6:													  
(get-process note*).StartTime = get-date              # get-date liefert ihnen übrigens das aktuelle Datum
                                                      # StartTime ist ReadOnly und kann/darf somit nicht überschrieben werden
													  
#Aufgabe 7:
get-process notepad.getType                           # Funktioniert nicht, weil die Klammern um "get-process notepad" fehlen
(get-process notepad).getType                         # Funktioniert nicht, weil die Klammern nach "getType" fehlen
(get-process notepad).getType()                       # Schon besser! (get-process notepad) präsentiert das Prozessobjekt
(get-process notepad).tostring()                      # Zeigt Standard-Infotext
(get-process notepad).kill()                          # Das ist der korrekte Befehl, um  den Prozess "notepad.exe" zu beenden

#Aufgabe 8:
Get-Process | Foreach-Object {                        # Alle Prozesse anzeigen, die "win" im Namen haben
  if ($_.ProcessName –like  "*win*")                  # Achtung, funktioniert so nicht: $_.ProcessName –eq  "*win*"
  {
    $_.ProcessName
  }
}

1. Lesen sie eine Textzeile ein und geben sie anschliessend die letzten drei Buchstaben des eingegebenen Textes wieder aus.
2. Machen sie aus dem String: [string]$myStr = "meinText.txt" den folgenden String: meinText.bck.
3. Gegeben sei:

   [string]$myStr = ""
   $myStr = read-host "Text eingeben, in der Art textteil1.textteil2"
   

   Ersetzen sie nun den Teil nach dem Punkt durch "xxx". (Bsp.: meinText.bck wird zu meinText.xxx) Beachten sie, dass nach dem Punkt nicht unbedingt drei Zeichen folgen müssen wie bei der vorangegangenen Aufgabe. (Bsp.: meinText.abcdefgh soll auch zu meinText.xxx werden)

# Aufgabe-1
[string]$mytxt = "meinText.txt"
Write-Host $mytxt.Substring($mytxt.Length - 3)

# Aufgabe-2
[string]$mytxt = "meinText.txt"
Write-Host $mytxt.Replace("txt", "bck")

# Aufgabe-3
[string]$myTxt = "Hallo.Welt"
[string[]]$myTxtArr = $myTxt.split(".")
$myTxt = $myTxtArr[0] + ".xxx"

Diese Aufgabe handelt vom Standardobjekt DateTime bzw. DateTime-Methoden und DateTime-Funktionen:
Berechnen sie, wievielmal mal sie noch schlafen müssen, bis das nächste Mal der Osterhase kommt.

[DateTime]$Datum1 = Get-Date "13.3.2020"
[DateTime]$Datum2 = Get-Date "24.3.2020" #...oder wann auch immer der Osterhase kommt
[int]$anzTage = ($Datum2 - $Datum1).TotalDays

1. Verzeichnis erstellen A: Verwenden sie für die folgenden Aufgaben die Powershell-ISE und ausschliesslich CmdLets und keine CmdTools:
   • Wechseln sie in ihr HomeVerzeichnis und danach in .\Desktop
   • Erstellen sie darin das Unterverzeichnis .\Test
   • Wechseln sie in das neu erstellte Verzeichnis .\Test
   • Setzen sie den Arbeitspfad (aktueller Pfad) auf ihr aktuelles Arbeitsverzeichnis. (Tipp: CurrentDirectory)
   • Kreieren sie ein Unterverzeichnis mit dem Namen "Backup". Prüfen sie vorher, ob es nicht bereits existiert.
   • Kreieren sie folgende Dateien "a.txt" mit dem Inhalt "Hello World" und "b.txt" mit dem Inhalt "Felix Muster is watching you"
   • Erstellen sie im Verzeichnis "Backup" ein Backup von ihrer bestehenden Datei "a.txt". Nennen sie diese Backup-Datei dann a.bck (Tipp: .CopyTo(..))
   • Listen sie das aktuelle und alle Unterverzeichnisse in die Datei "c.txt"
   • Verschieben sie die Datei "c.txt" in das Verzeichnis .\Backup
   • Erstellen sie eine Liste mit allen Prozessen, die das Pattern "win" in Namen tragen. Diese Datei soll d.txt heissen.
   • Löschen sie die Datei "d.txt"
   • Verschieben sie alle im aktuellen Verzeichnis verbliebenen Text-Dateien in das Verzeichnis .\Backup. (Tipp: Move-Item))
2. Verzeichnis erstellen B: Mit diesem Script soll ein Verzeichnis erstellt werden, sofern es nicht bereits existiert.
   • Eingabe mit folgendem Begleittext "Bitte Verzeichnisname eingeben"
   • Ausgabe, falls Verzeichnis noch nicht existiert: "Das Verzeichnis xxx wurde erstellt"
   • Sonst Ausgabe "Das Verzeichnis xxx existiert bereits"
3. Datei auswählen und kopieren: Nun sollen sie die in den vorangegangenen Aufgaben erlernten CmdLets in ein Skript einbauen. Erstellen sie den Powershell-Skript für die folgende Aufgabe:
   • Anzeige aller Dateien (keine Verzeichnisse) im aktuellen Verzeichnis
   • Auswahl des Filenamens, von dem eine Kopie erstellt werden soll.
   • Überprüfung, ob der angegebene Dateiname existiert, sonst Fehlermeldung und erneute Abfrage.
   • Bei erfolgreichem Kopieren: Erfolgsmeldung an den Benutzer mit Angabe des Filenamens der Kopie.
   • Wiederholung des ganzen Vorgangs für die Erstellung einer weiteren Kopie oder Abbruch (Programm verlassen)
4. Dateiarchiv: Erstellen sie ein Powershell-Skript für die folgende Aufgabe:
   Variante-1:
   • Der Benutzer gibt den Namen einer Datei an, die archiviert werden soll.
   • Das Programm prüft, ob die Datei existiert. Wenn Nein wird eine Fehlermeldung ausgegeben und das Programm beendet.
   • Der Benutzer gibt das Zielverzeichnis an, in das die Datei archiviert werden soll.
   • Das Programm prüft, ob das Zielverzeichnis existiert. Wenn Nein wird eine Fehlermeldung ausgegeben und das Programm beendet.
   • Das Programm prüft das Archivbit der Datei. Wenn es gesetzt ist, wird der Kopiervorgang ausgelöst und eine Vollzugsmeldung ausgelöst.  Falls das Archivbit nicht gesetzt ist, gibt das Programm die Meldung aus, dass die Datei nicht archiviert werden muss.
   • Testen sie das Programm gründlich. Spielen sie alle möglichen Fälle durch, auch den Fall "ArchivBit gesetzt" und "Archivbit nicht gesetzt".
   Variante-2:
   • Sie möchten ein komplettes Verzeichnis (keine Unterverzeichnisse) archivieren.
   • Der Benutzer gibt das Quellverzeichnis an.
   • Der Benutzer gibt das Zielverzeichnis an.
   • Falls das Zielverzeichnis nicht existiert, muss es zuerst erstellt werden.
   • Es werden alle Files vom Quellverzeichnis ins Zielverzeichnis kopiert.
   • Zusatzaufgabe1: Setzen sie das Archiv-Attribut der Originaldateien auf "Datei gesichert". (Tipp: Get-ItemProperty und Set-ItemProperty)
   • Zusatzaufgabe2: Archivieren sie nur die Dateien, wo das Archiv-Attribut gesetzt ist. Also nur diejenigen Dateien, die schon einmal archiviert und seither nicht angerührt worden sind.

1. Verzeichnis erstellen A:

   #Aufgabe 1:
   Set-Location c:\users\felixmuster\desktop
   
   #Aufgabe 2:
   New-Item -Path . -name "Test" -ItemType directory
   
   #Aufgabe 3:
   Set-Location .\Test
   
   #Aufgabe 4:
   [environment]::CurrentDirectory = Get-Location
   # Hinweis: [System.Environment]::CurrentDirectory enthält das Working-Directory des PowerShell-Prozesses
   # bzw. man kann, wie im obigen Beispiel gezeigt, es darüber setzen. 
   # Um hingegen das Working-Directory der Konsolen-Session zu lesen oder schreiben, verwendet man
   # das CommandLet Get-Location, Set-Location oder $pwd.
   
   #Aufgabe 5:
   $myPath = ".\Backup"
   if (!(Test-Path $myPath)) {New-Item -Path $myPath -ItemType Directory}
   # Hier zum Vergleich eine etwas lesbarere Version:
   $myPath = ".\Backup"
   if (Test-Path $myPath)   # → if ( (Test-Path $myPath) -eq $True )
   {
     write-host "Verzeichnis existiert bereits"
   }
   else
   {
     New-Item -Path $myPath -ItemType Directory
   }
   
   #Aufgabe 6:
   "Hello World" > a.txt
   "Felix Muster is watching you" > b.txt
   
   #Aufgabe 7:
   $myFile = Get-Item a.txt
   $myFile.CopyTo(".\Backup\a.bck", -1)
   
   #Aufgabe 8:
   Get-ChildItem . -recurse > c.txt
   # Hinweis: -recurse steht für Rekursiv und bezweckt, dass alle Zweige des Verzeichnisbaums
   # erfasst werden.
   
   #Aufgabe 9:
   Move-Item c.txt .\Backup
   
   #Aufgabe 10:
   Get-Process | Foreach-Object {
     if ($_.ProcessName –like  "*win*")
     {
       $_.ProcessName
     }
   }
   
   #Aufgabe 11:
   Remove-Item d.txt
   
   #Aufgabe 12:
   $myFileList = get-ChildItem *.txt
   $destDir = ".\Backup"
   Move-Item $myFileList $destDir
   

2. Verzeichnis erstellen B:

   # Programm-Header (arj/3.3.2020)***
   set-psdebug -strict
   # Variablendeklaration + Initialisierung
   [string]$dirname = ""
   [string]$pathname = (get-location).path
   cls
   $dirname = read-host "Bitte Verzeichnisname in $pathname eingeben"
   if( (Test-Path -path $dirname) -eq $True)
   {
     write-host "Das Verzeichnis $dirname existiert bereits."
   }
   else
   {
     New-Item -Path . -name $dirname -ItemType directory
     write-host "Das Verzeichnis $dirname wurde erstellt."
   }
   

3. Datei auswählen und kopieren:

   # Programm-Header (ARJ/22.3.2020)***
   set-psdebug -strict
   # Variablendeklaration + Initialisierung
   [string]$meinStandort = Get-Location
   [string]$meinDateinamen = ""
   [string[]]$meinSeparierterDateinamen  # String-Array
   [string]$meinBackupnamen = ""
   [char]$fortsetzen = "n"
   
   # Hauptprogramm
   cls
   [environment]::CurrentDirectory = $meinStandort
   write-host $meinStandort
   do
   {
     Get-ChildItem -file -name
     # Datei auswaehlen
     $meinDateinamen = read-Host "Von welcher Datei soll ein Backup erstellt werden?"
     #Dateiexistenz ueberpruefen
     if(Test-Path -path $meinDateinamen)
     {
       $meinSeparierterDateinamen = $meinDateinamen.split(".")    # Dateinamen [Namen.Extension] in zwei Arrayelemente aufteilen 
       $meinBackupnamen = $meinSeparierterDateinamen[0] + ".bck"  # Neuer Dateinamen zusammensetzen
       Copy-Item $meinDateinamen $meinBackupnamen                 # Kopieren
       write-host "$meinBackupnamen wurde erstellt"               # Meldung an Benutzer
     }
     else
     {
        write-host "$meinDateinamen ist nicht vorhanden"
     }
     $fortsetzen = read-Host "Sollen weitere Backups erstellt werden? [j/n]"
   } while($fortsetzen -eq "j")
   write-host "Programm beendet."
   

4. Dateiarchiv:

   # Programm-Header (ARJ/22.3.2020)***
   set-psdebug -strict
   # Variablendeklaration + Initialisierung
   [string]$meinStandort = Get-Location
   [string]$meinQuellVerzeichnis = ""
   [bool]$QuellverzeichnisOK = $False
   [string]$meinZielVerzeichnis = ""
   [bool]$ZielverzeichnisOK = $False
   # Hauptprogramm
   cls
   [environment]::CurrentDirectory = $meinStandort  # Aktueller Standort setzen
   # Quellverzeichnis
   $meinQuellVerzeichnis = read-Host "Quellverzeichnis, aus dem Dateien archiviert werden sollen"
   if(Test-Path -path $meinQuellVerzeichnis)                   # Pruefen ob Quellverzeichnis vorhanden ist
   {
     if( ((get-childitem $meinQuellVerzeichnis).count) -eq 0)  # Pruefen ob Quellverzeichnis leer ist
     {
       write-host "Das Verzeichnis $meinQuellVerzeichnis ist leer"
     }
     else
     {
       $QuellverzeichnisOK = $True
     }
   }
   else
   {
     write-host "Das Verzeichnis $meinQuellVerzeichnis ist nicht vorhanden"
   }
   if($QuellverzeichnisOK)  # Wenn Eingabe von Quellverzeichnis erfolgreich war...
   {
     #Zielverzeichnis
     $meinZielVerzeichnis = read-Host "Zielverzeichnis, in das die Dateien archiviert werden sollen"
     if(Test-Path -path $meinZielVerzeichnis)                   # Pruefen ob Zielverzeichnis vorhanden ist
     {
       if( ((get-childitem $meinZielVerzeichnis).count) -eq 0)  # Pruefen ob Zielverzeichnis leer ist
       {
         $ZielverzeichnisOK = $True
       }
       else
       {
         write-host "Das Verzeichnis $meinQuellVerzeichnis ist nicht leer. Bitte ein anderes Zielverzeichnis waehlen."
       }
     }
     else
     {
       $ZielverzeichnisOK = $True
       New-Item -Path $meinZielVerzeichnis -ItemType Directory | Out-Null  # Mit Out-Null wird die Ausgabe von New-Item unterdrueckt
     }
     if($ZielverzeichnisOK)  # Wenn Eingabe von Zielverzeichnis erfolgreich war, soll nun kopiert werden
     {
       $meineDateiliste = get-ChildItem $meinQuellVerzeichnis
       foreach($meineDatei in $meineDateiliste) {
         if($meineDatei.mode -eq "-a----")  # Nur Dateien mit gesetztem Archiv-Bit kopieren
         {
           $meineDatei.CopyTo($meinZielVerzeichnis + "\" + ($meineDatei.Name), -1) | Out-Null  
           # Zielpfad/Dateiname richtig zusammensetzen!
         }
       }
       set-itemproperty $meinZielVerzeichnis\*.* -Name Attributes -Value "Normal"
       write-host "Alle Dateien aus $meinQuellVerzeichnis wurden erfolgreich nach $meinZielVerzeichnis kopiert."
     }
   }
   # Hinweis zum Dateiattribut "Archive":
   # In den Dateieigenschaften findet man unter Allgemein/Erweitert das Archive-Attribut.
   # Dieses Attribut lässt sich mit dem folgenden Win-Programm ändern:
   # attrib.exe meinFile -A (Löscht das Archiv-Bit =0)
   # attrib.exe meinFile +A (Setzt das Archiv-Bit =1)
   # Ist das Archiv-Bit auf 0, wird es automatisch vom Betriebssystem auf 1 gesetzt, wenn auf das File schreibend zugegriffen wird.
   # Das Archiv-Bit kann z.B. von einer Backup-SW ausgewertet werden.
   # In Powershell:
   # set-itemproperty meinFile -Name Attributes -Value "Normal" → Löscht alle Attribute, auch das Archive-Attribut
   # set-itemproperty meinFile -Name Attributes -Value "Archive" → Setzt das Archive-Attribut
   # ($meineDatei.mode -eq "-a----") → Das Datei-Attribut in der Objekt-Eigenschaft "Mode" ausgewertet (Mode ist schreibgeschützt)
   

Lokalen Benutzer mit Angaben aus einer EXCEL-Datei erstellen:

• Erstellen sie eine EXCEL-Datei mit dem Namen "Benutzer.xlsx".
• Tragen sie in Tabelle1 Feld A1 den Namen "FelixMuster" ein.
• Tragen sie in Tabelle1 Feld A2 das Passwort "geheim" ein.
• Benennen sie die Tabelle anstatt wie bisher "Tabelle1" neu "Benutzer"
• Erstellen sie einen Powershell-Skript, der die beiden Felder A1 und A2 aus der Tabelle "Benutzer.xlsx" ausliest und mit write-host anzeigt.
• Erstellen sie einen Powershell-Skript, der aus den Angaben in Tabelle "Benutzer.xlsx" einen lokalen Windows-User erstellt.
• Prüfen sie ihr Programm gründlich.

Lokalen Benutzer mit Angaben aus einer EXCEL-Datei erstellen:

# Zweck        : Benutzer gemaess Excel-Tabelleneintrag erstellen
# Autor/Datum  : Arj/April 2020
# Voraussetzung: Sie haben in E:\test eine Exceldatei mit dem Namen Benutzertabelle.xlsx
#                Die Tabelle besitzt ein Blatt (Sheet) mit dem Namen Benutzer
#                In der Zelle A1 ist der Benutzername eingetragen
#                In der Zelle A2 ist das Passwort eingetragen
# Falls sie von diesen Angaben abweichen, muss das im folgenden Skript entsprechend angepasst werden. 
set-strictmode -version latest  # Must-have!
[string]$thePath = "E:\test\Benutzertabelle.xlsx"
[string]$theTable = "Benutzer"
[string]$myUsername = ""
[string]$myPassword = ""
[System.Security.SecureString]$mySecurePassword
[object]$myExcel
[object]$myWorkbook
[object]$myTable
cls # Konsolenanzeige leeren
$myExcel = New-Object -ComObject excel.application                     # Excel starten
$myWorkbook = $myExcel.Workbooks.Open($thePath)                        # Excel-Dokument oeffnen
$myTable =$myWorkbook.Worksheets.Item($theTable)                       # Tabelle waehlen    
$myUsername = $myTable.Cells.Item(1,1).Text                            # Ausgabe des Texts in Excel-Zelle A1
$myPassword = $myTable.Cells.Item(2,1).Text                            # Ausgabe des Texts in Excel-Zelle A2
$myExcel.Quit()                                                        # Beendung von Excel
Remove-Variable myTable, myWorkbook, myExcel                           # Variablen wieder entfernen
write-host "Es wird der Benutzer ""$myUsername"" mit dem Passwort ""$myPassword"" erstellt..."
$mySecurePassword = ConvertTo-SecureString -String $myPassword -AsPlainText -Force
New-LocalUser -Name $myUsername -Password $mySecurePassword
# Am Schluss nicht vergessen, den neu erstellten Benutzer wieder zu loeschen: cmd-Tool → lusrmgr.msc

1. Laufende Prozesse zählen: Es sollen mit diesem Skript alle auf dem PC laufenden Prozesse zusammengezählt und das Resultat in der folgenden Art ausgegeben werden: "Aktuell sind xxx Prozesse am laufen"
   Tipp: Get-Process
2. Höchste Prozesszeit anzeigen: Ausgehend von der vorangegangenen Aufgabe soll nun der Prozess mit der grössten TotalProcessorTime angezeigt werden.
   Hinweis: Probieren sie die ProzessObjekt-Property TotalProcessorTime zuerst aus. Sie werden sehen, dass verschiedene Zeitangaben erscheinen. Welche ist für diese Aufgabe am sinnvollsten? Aufruf: TotalProcessorTime.yyyyyyy
3. Prozessverwaltung: Erstellen sie ein Skript für die Prozessverwaltung. Die folgenden Aktionen sollen über ein Benutzermenü angeboten werden:
   • Anzeige aller laufenden Prozesse
   • Suche nach bestimmten Prozessen
   • Statusanzeige bzw. auf Wunsch Anzeige weiterer Eigenschaften eines bestimmten Prozesses
   • Anzeige des gesamten RAM-Verbrauchs aller Prozesse
   • Anzeige der CPU-Auslastung
   • Zusatzaufgabe: Logfile über RAM-Verbrauch und CPU-Auslastung erstellen
4. Eventlog anzeigen: Um zu zeigen, dass Powershell fü Systemtechniker wirklich hilfreich sein kann, lesen wir nun das SYSTEM-Eventlog aus:
   • Angezeigt werden soll: LogName=System und EntryType=Error
   • Eingabe: Startdatum, ab welchem die Einträge gezeigt werden
   • Eingabe: Enddatum, bis zu welchem die Einträge gezeigt werden
   • Tipp: Get-EventLog. Start- und Enddatumseingabe sind eine kleine Knacknuss ;-)

1. Laufende Prozesse zählen:

   # Programm-Header ***
   set-psdebug -strict
   # Variablendeklaration und Initialisierung
   [int64]$i = 0
   cls
   Get-Process | Foreach-Object{
     $i = $i + 1
   }
   write-host "Aktuell sind $i Prozesse am laufen"
   

2. Höchste Prozesszeit anzeigen:

   # Programm-Header ***
   set-psdebug -strict
   # Variablendeklaration + Initialisierung
   [long]$maxProcTime = 0 
   [string]$procName = ""
   cls
   Get-Process | Foreach-Object {
     if($_.TotalProcessorTime -ge $maxProcTime)
     {
       $maxProcTime = $_.TotalProcessorTime.Ticks
       $procName = $_.ProcessName
     }
   }
   write-host "Der Prozess $procName weist mit $maxProcTime die hoechste TotalProcessorTime aus."
   

3. Prozessverwaltung: Keine Musterlösung vorhanden.
4. Eventlog anzeigen:

   # Programmheader (arj/3.3.2020)
   set-strictmode -version latest
   # Variablen-Deklaration & Initialisierung 
   [string]$readDate = ""
   [datetime]$startDate = get-date
   [datetime]$EndDate = get-date
   [bool]$nok = $True
   cls
   do #Startdatum einlesen
   {
     $readDate = Read-Host "Startdatum (ddMMyyyy)"
     try
     {
       $startDate = [datetime]::parseExact($readDate,"ddMMyyyy",$null)
       $nok = $False
     }
     catch
     {
       write-host "Bitte korrektes Format!"
       $nok = $True
     } 
   }while($nok)
   do #Enddatum einlesen
   {
     $readDate = Read-Host "Enddatum (ddMMyyyy)"
     try
     {
       $EndDate = [datetime]::parseExact($readDate,"ddMMyyyy",$null)
       $nok = $False
     }
     catch
     {
       write-host "Bitte korrektes Format!"
       $nok = $True
     } 
   }while($nok)
   # Eventlog auslesen
   Get-EventLog -LogName System -EntryType Error -After $StartDate -Before $EndDate
   

Taschenrechner: Bis jetzt haben wir immer textbasierte Benutzerschnittstellen erstellt. Das geht aber auch grafisch mit .net-Objekten.
Erstellen sie einen Rechner mit robuster grafischer Eingabe, wo sie einen Winkel (Dezimalzahl) im Gradmass eingeben und davon den Sinuswert (Dezimalzahl) berechnen. Nutzen Sie die entspprechende Library.
(Beachten sie, dass bei der Sinusfunktion der Winkel im Bogenmass eingegebn wird. Dabei gilt: 360° entsprechen 2π. Der Sinus ist definiert von -∞ bis + ∞)

Keine Musterlösung vorhanden.

1. Datumsarithmetik:
   • Lesen Sie zwei Daten ein und berechnen Sie die Differenz in Monaten.
   • Lesen Sie ein Datum ein und bestimmen Sie, ob es in diesem Jahr einen 29. Februar gibt (=Schaltjahr).
2. Wordprocessing:
   • Lesen Sie einen Satz ein und zählen Sie die Anzahl Worte.
   • Suchen Sie ihr gesamtes "~\"-Verzeichnis nach Dateien ab, die die Endung ".html" enthalten.
3. Dateioperationen: Sie erhalten in einem ZIP-File verschiedene Bilddateien von verschiedenen Szenen: AlleSzenen.zip Entpacken sie diese. Das Programm soll auf die entpackte ZIP-Datei angewendet werden und folgende Funktionen nacheinander ausführen:
   • Durchsuchen der Dateinamen nach dem Sonderzeichen "#" und ersetzen durch "_".
   • Löschen aller Dateien, die "Kopie" im Dateinamen enthalten.
   • Verschieben aller Dateien derselben Szene in einen eigenen Szene-Ordner.
   • Bei allen Dateien die Eigenschaft "CreationTime" auf die aktuelle Zeit setzen.

#******************************************************************************
# ARJ, DATUM:   MAR-2021
#******************************************************************************
set-strictmode -version latest               # Codierungsregeln verschärfen

#******************* Variablen-Deklaration & Initialisierung ******************
[DateTime]$Datum_A = Get-Date "1.1.1970"     # Verwendet in Aufgabe 1.
[DateTime]$Datum_B = Get-Date "1.1.1970"     # Verwendet in Aufgabe 1.
[int]$Datum_Diff = 0                         # Verwendet in Aufgabe 1.

[string]$myText = ""                         # Verwendet in Aufgabe 2.
[int]$NumberOfWords = 0                      # Verwendet in Aufgabe 2.

[Object]$myFiles                             # Verwendet in Aufgabe 3.
[Object]$File                                # Verwendet in Aufgabe 3.
[string]$newFilename = ""                    # Verwendet in Aufgabe 3.

#******************* HIER BEGINNT PROGRAMM 1. *******************************
# 1-1. Lesen Sie zwei Daten ein und berechnen Sie die Differenz in Monaten.
# 1-2. Lesen Sie ein Datum ein und bestimmen Sie, ob es in diesem Jahr einen 29. Februar gibt.
# Somit wäre das Jahr ein Schaltjahr.
cls

# *** Datum für Aufgabe 1-1 und 1-2 eingeben:
$Datum_A = Read-Host "Bitte erstes Datum im Format dd.mm.yyyy eingeben"
$Datum_A = Get-Date -Format "dd.MM.yyy" $Datum_A
$Datum_B = Read-Host "Bitte zweites Datum im Format dd.mm.yyyy eingeben"
$Datum_B = Get-Date -Format "dd.MM.yyy" $Datum_B  
 
# *** Aufgabe 1-1.: (Hinweis Anzahl Jahre mitberücksichtigen)       
$Datum_Diff = ($Datum_B.year - $Datum_A.year) * 12 + ($Datum_B.month - $Datum_A.month)
Write-Host "Anzahl Monate inkl. angebrochenen: $Datum_Diff"

# *** Aufgabe 1-2.:
if( ($Datum_A.year % 4 -eq 0) -and ($Datum_A.year % 100 -ne 0) -or ($Datum_A.year % 400 -eq 0) ) {
  Write-Host "Der Februar im Jahr $myYear zaehlt 29 Tage!"
}

#******************* HIER BEGINNT PROGRAMM 2. *******************************
# 2-1. Lesen Sie einen Satz ein und zählen Sie die Anzahl Worte.
# 2-2. Suchen Sie ihr gesamtes "~\"-Verzeichnis nach Dateien ab, die die Endung ".html" enthalten.
cls

# *** Aufgabe 2-1.:
$myText = Read-Host "Bitte eine Textzeile eingeben"
$NumberOfWords = ($myText | Measure-Object -Word).words
write-host "Der Text ""$myText"" enthält $NumberOfWords Wörter."

# *** Aufgabe 2-2.:
$myFileList = get-ChildItem ~ -recurse     # Zeigt alle Verzeichnisse ab Homeverzeichnis an
foreach($myFile in $myFileList) {
  if( ($myFile.PSISContainer -eq $False) -and ($myFile.Name).Contains(".html") ) {
    Write-Host $myFile.Name
  }
}

#******************* HIER BEGINNT PROGRAMM 3. *******************************
# 3-1. Durchsuchen der Dateinamen nach dem Sonderzeichen "#" und ersetzen durch "_".
# 3-2. Löschen aller Dateien, die "Kopie" im Dateinamen enthalten.
# 3-3. Verschieben aller Dateien derselben Szene in einen eigenen Szene-Ordner.
# 3-4. Bei allen Dateien die Eigenschaft "CreationTime" auf die aktuelle Zeit setzen.
Set-Location C:\Users\FelixMuster\Desktop\M404\AlleSzenen
cls

# *** Aufgabe 3-1.:
$myFiles = Get-ChildItem
if($myFiles -ne $NULL) {
  foreach($File in $myFiles) {
    $newFilename = $File -replace "#","_"
    if ((Test-Path $newFilename) -eq $False) {
      Rename-Item $File $newFilename
    }
  } 
}

# *** Aufgabe 3-2.:
$myFiles = Get-ChildItem
if($myFiles -ne $NULL) {
  foreach($File in $myFiles) {
    if($File -match "Kopie") {
      $File.Delete()
    }
  } 
}

# *** Aufgabe 3-3.:
$myFiles = Get-ChildItem
if($myFiles -ne $NULL) {
  if ((Test-Path Szene_2) -eq $False) {
    New-Item -ItemType Directory -Name Szene_2
  }
  foreach($File in $myFiles) {
    if($File -match "Szene_2") {
      Move-Item -Path $File -Destination Szene_2
    }
  } 
}

# *** Aufgabe 3-4.:
$myFiles = Get-ChildItem
if($myFiles -ne $NULL) {
  foreach($File in $myFiles) {
    (Get-Item $File).CreationTime = [DateTime]::Now
    (Get-Item $File).LastAccessTime = [DateTime]::Now
    (Get-Item $File).LastWriteTime = [DateTime]::Now
  } 
}