🔫 💓 🙇🏾 Was ist Windows PowerShell und was isst es? Teil 2: Einführung in die Programmiersprache 🗽 👣 🔖

In der Vergangenheit sind Befehlszeilenprogramme auf Unix-Systemen besser entwickelt als unter Windows. Mit dem Aufkommen einer neuen Lösung hat sich die Situation jedoch geändert.

Für PowerShell können Sie Skripte in einer interpretierten Multi-Paradigmen-Sprache schreiben, die Elemente der klassischen prozeduralen, objektorientierten und sogar funktionalen Programmierung enthält: bedingte Verzweigung, Schleifen, Variablen, Arrays, Hash-Tabellen, Klassen, Fehlerbehandlung sowie Funktionen, Cmdlets und Pipelines . Der vorherige Artikel war den Grundlagen des Arbeitens in einer Umgebung gewidmet, und jetzt bieten wir unseren Lesern einen kleinen Leitfaden für Programmierer.

Inhaltsverzeichnis:

Kommentare
Variablen und deren Typen
Systemvariablen
Scopes
Umgebungsvariablen (
Arithmetik ) Rechen- und
Vergleichsoperatoren Zuweisungsoperatoren
Logische Operatoren
Conditional Übergang
Loops
Arrays
Hash - Tabellen -
Funktionen
Fehlerbehandlung Sie

Code in einem beliebigen Texteditor schreiben oder die integrierte Entwicklungsumgebung - der einfachste Weg zu nehmen Windows PowerShell ISE ist in Microsoft Server-Betriebssystemen enthalten. Dies ist nur für recht komplexe Skripte erforderlich: Kurze Befehlssätze lassen sich leichter interaktiv ausführen.

Bemerkungen

Die Verwendung von Kommentaren wird zusammen mit den richtigen Einrückungen und Leerzeichen als Teil eines guten Programmierstils angesehen:

#       —     .

<# 

             . 
            .

#>

Variablen und ihre Typen

Variablen in PowerShell sind benannte Objekte. Ihre Namen können einen Unterstrich sowie Buchstaben und Zahlen enthalten. Das $ -Symbol wird immer vor dem Namen verwendet.

Bild

Um eine Variable zu deklarieren, reicht es aus, dem Interpreter einen gültigen Namen anzuzeigen: Um die Variable zu initialisieren (ihr einen Wert zuzuweisen), wird der Zuweisungsoperator (symbol =) verwendet:

$test = 100

Sie können eine Variable deklarieren, indem Sie ihren Typ in eckigen Klammern (Typkonvertierungsoperator) vor dem Namen oder Wert angeben:

[int]$test = 100

$test = [int]100

Es ist wichtig zu verstehen, dass Variablen in PowerShell vollwertige Objekte (Klassen) mit Eigenschaften und Methoden sind, deren Typen auf den in .NET Core verfügbaren basieren. Wir listen die wichtigsten auf:

Typ (.NET-Klasse)	Beschreibung	Codebeispiel
[string] System.String	Unicode	$test = «» $test = ''
[char] System.Char	Unicode (16 )	[char]$test = 'c'
[bool] System.Boolean	( True False)	[bool]$test = $true
[int] System.Int32	(32 )	[int]$test = 123456789
[long] System.Int64	(64 )	[long]$test = 12345678910
[single] System.Single	32	[single]$test = 12345.6789
[double] System.Double	64 (8 )	[double]$test = 123456789.101112
[decimal] System.Decimal	128-Bit-Gleitkommazahl (am Ende unbedingt d einfügen)	[dezimal] $ test = 12345.6789d
[DateTime] System.DateTime	Datum (und Uhrzeit	$ test = Get-Date
[Array] System.Object []	Ein Array, dessen Elementindex bei 0 beginnt	$ test_array = 1, 2, "test", 3, 4
[hashtable] System.Collections.Hashtable	Hash-Tabellen - assoziative Arrays mit benannten Schlüsseln, basierend auf dem Prinzip: @ {key = "value"}	$ test_hashtable = @ {one = "one"; zwei = "zwei"; drei = "drei"}

PowerShell unterstützt die implizite Typkonvertierung. Außerdem kann sich der Typ der Variablen im laufenden Betrieb ändern (z. B. mithilfe des Zuweisungsoperators), wenn er nicht zwangsweise angegeben wird. In diesem Fall gibt der Interpreter einen Fehler aus. Sie können den Typ einer Variablen aus dem vorherigen Beispiel ermitteln, indem Sie die GetType () -Methode aufrufen:

$test.GetType().FullName

Es gibt eine Reihe von Cmdlets zum Verwalten von Variablen. Ihre Liste in praktischer Form wird mit dem folgenden Befehl angezeigt:

Get-Command -Noun Variable | ft -Property Name, Definition -AutoSize -Wrap

Um die deklarierten Variablen und ihre Werte anzuzeigen, können Sie das spezielle Cmdlet verwenden:

Get-Variable | more

Diese Methode scheint zu umständlich zu sein. Es ist viel bequemer, mit Variablen über Operatoren oder durch direkten Zugriff auf deren Eigenschaften und Methoden zu arbeiten. Cmdlets haben jedoch ein Existenzrecht, da Sie damit einige zusätzliche Parameter angeben können. Es ist wichtig zu verstehen, dass Benutzervariablen nur innerhalb der aktuellen Sitzung definiert werden. Nach dem Schließen der Konsole oder dem Ausfüllen des Skripts werden sie gelöscht.

Systemvariablen

Zusätzlich zu den vom Benutzer deklarierten gibt es integrierte (System-) Variablen, die nach dem Ende der aktuellen Sitzung nicht gelöscht werden. Sie werden in zwei Typen unterteilt, während PowerShell-Statusdaten in automatischen Variablen gespeichert werden, denen keine eigenen Werte zugewiesen werden können. Dazu gehören beispielsweise $ PWD:

$PWD.Path

Zum Speichern von Benutzereinstellungen benötigen Sie Voreinstellungsvariablen, deren Werte geändert werden können. Mit Hilfe von $ ErrorActionPreference wird beispielsweise die Antwort des Befehlsinterpreters auf das Auftreten unkritischer Fehler festgelegt.

Zusätzlich zu Operatoren und Cmdlets gibt es den Pseudoakkumulator Variable: für den Zugriff auf deklarierte Variablen. Sie können analog zu anderen Laufwerken damit arbeiten, und die Variablen ähneln in diesem Fall Dateisystemobjekten:

Get-ChildItem Variable: | more

oder

ls Variable: | more

Geltungsbereich

Für Variablen in PowerShell gibt es den Begriff Scope. Die Aktion des globalen Bereichs (Global) erstreckt sich auf die gesamte aktuelle Sitzung - sie umfasst beispielsweise Systemvariablen. Lokale Variablen sind nur in dem Bereich verfügbar, in dem sie definiert wurden: Sagen wir innerhalb der Funktion. Es gibt auch das Konzept eines Skriptbereichs, aber für Skriptbefehle ist es im Wesentlichen lokal. Wenn Sie Variablen deklarieren, erhalten sie standardmäßig einen lokalen Bereich. Um dies zu ändern, ist eine spezielle Konstruktion des Formulars erforderlich: $ Global: variable = value.

Zum Beispiel so:

$Global:test = 100

Umgebungsvariablen

Ein weiteres Env-Pseudo-Laufwerk ist von PowerShell erhältlich, mit dem auf Umgebungsvariablen zugegriffen werden kann. Wenn die Shell gestartet wird, werden sie vom übergeordneten Prozess (d. H. Von dem Programm, das die aktuelle Sitzung initiiert hat) kopiert, und normalerweise stimmen ihre Anfangswerte mit den Werten im Bedienfeld überein. Verwenden Sie zum Anzeigen von Umgebungsvariablen das Cmdlet Get-ChildItem oder seine Aliase (liases): ls und dir.

dir Env:

Diese Variablen sind Folgen von Bytes (oder Zeichen, wenn Sie möchten), deren Interpretation nur von dem Programm abhängt, das sie verwendet. * -Variable Cmdlets funktionieren nicht mit Umgebungsvariablen. Um darauf zuzugreifen, müssen Sie das Festplattenpräfix verwenden:

$env:TEST = "Hello, World!"

Arithmetik- und Vergleichsoperatoren

PowerShell verfügt über die folgenden arithmetischen Operatoren: + (Addition), - (Subtraktion), * (Multiplikation), / (Division) und% (Modul oder Rest der Division). Das Ergebnis eines arithmetischen Ausdrucks wird von links nach rechts gemäß der allgemein akzeptierten Reihenfolge der Operationen berechnet, und Klammern werden verwendet, um Teile des Ausdrucks zu gruppieren. Leerzeichen zwischen Operatoren werden ignoriert und nur zur Erleichterung der Wahrnehmung verwendet. Der Operator + verkettet ebenfalls und der Operator * wiederholt die Zeilen. Wenn Sie versuchen, einer Zeichenfolge eine Zahl hinzuzufügen, wird diese in eine Zeichenfolge konvertiert. Darüber hinaus verfügt PowerShell über viele Vergleichsoperatoren, die die Entsprechung zwischen zwei Werten überprüfen und den booleschen Wert True oder False zurückgeben:

Operator	Beschreibung	Codebeispiel
-eq	Gleich (analog = oder == in anderen Sprachen)	$ test = 100 $ test -eq 123
-ne	Nicht gleich (analog <> oder! =)	$ test = 100 $ test -ne 123
-gt	Größer als / Mehr (analog>)	$ test = 100 $ test -gt 123
-ge	Größer als oder gleich / Größer als oder gleich (analog> =)	$ test = 100 $ test -ge 123
-lt	Weniger als (analog <)	$ test = 100 $ test -lt 123
-le	Weniger als oder gleich / Weniger als oder gleich (analog <=)	$ test = 100 $ test -le 123

Es gibt andere ähnliche Operatoren, mit denen beispielsweise Zeichenfolgen mit einem Platzhalterzeichen verglichen oder reguläre Ausdrücke zum Abgleichen von Mustern verwendet werden können. Wir werden sie in den folgenden Artikeln ausführlich betrachten. Die Symbole <,> und = werden nicht zum Vergleich verwendet, da sie für andere Zwecke verwendet werden.

Zuweisungsoperatoren

Neben dem häufigsten Operator = gibt es weitere Zuweisungsoperatoren: + =, - =, * =, / = und% =. Sie ändern den Wert vor der Zuordnung. Die unären Operatoren ++ und - verhalten sich ähnlich, die den Wert einer Variablen erhöhen oder verringern - beziehen sich auch auf Zuweisungsoperatoren.

Logische Operatoren

Ein Vergleich reicht nicht aus, um schwierige Bedingungen zu beschreiben. Sie können alle logischen Ausdrücke mit den folgenden Operatoren aufschreiben: -and, -or, -xor, -not und! .. Sie funktionieren wie in anderen Programmiersprachen, während Sie die Berechnungsreihenfolge in Klammern angeben können:

("" -eq "") -and (100 -eq 100)

-not (123 -gt 321) 

!(123 -gt 321)

Bedingter Sprung

Die Verzweigungsoperatoren in PowerShell sind Standard: IF (IF ... ELSE, IF ... ELSEIF ... ELSE) und SWITCH. Betrachten Sie ihre Verwendung anhand von Beispielen:

[int]$test = 100
if ($test -eq 100) {
      Write-Host "test = 100"
}



[int]$test = 50
if ($test -eq 100) {
       Write-Host "test = 100"
}
else {
      Write-Host "test <> 100"
}



[int]$test = 10
if ($test -eq 100) {
      Write-Host "test = 100"
}
elseif ($test -gt 100) {
      Write-Host "test > 100"
}
else {
       Write-Host "test < 100"
}



[int]$test = 5
switch ($test) {
     0 {Write-Host "test = 0"}
     1 {Write-Host "test = 1"}
     2 {Write-Host "test = 2"}
     3 {Write-Host "test = 3"}
     4 {Write-Host "test = 4"}
     5 {Write-Host "test = 5"}
     default {Write-Host "test > 5    "}
}

Fahrräder

In PowerShell gibt es verschiedene Arten von Schleifen: WHILE, DO WHILE, DO UNTIL, FOR und FOREACH.

Die Vorbedingungsschleife funktioniert, wenn / während sie ausgeführt wird:

[int]$test = 0
while ($test -lt 10) {
      Write-Host $test
      $test = $test + 1
}

Schleifen mit einer Nachbedingung funktionieren mindestens einmal, da die Bedingung nach der Iteration überprüft wird. In diesem Fall funktioniert DO WHILE, solange die Bedingung erfüllt ist, und DO UNTIL - solange es falsch ist:

[int]$test = 0
do {
      Write-Host $test
      $test = $test + 1 
}
while ($test -lt 10)



[int]$test = 0
do {
      Write-Host $test
      $test = $test + 1 
}
until ($test -gt 9)

Die Anzahl der Iterationen der FOR-Schleife ist im Voraus bekannt:

for ([int]$test = 0; $test -lt 10; $test++) {
       Write-Host $test
}

In einer FOREACH-Schleife werden Elemente eines Arrays oder einer Sammlung (Hash-Tabelle) durchlaufen:

$test_collection = "item1", "item2", "item3"
foreach ($item in $test_collection)
{
        Write-Host $item
}

Arrays

PowerShell-Variablen speichern nicht nur einzelne Objekte (Nummer, Zeichenfolge usw.), sondern auch mehrere. Die einfachste Variante solcher Variablen sind Arrays. Ein Array kann aus mehreren Elementen bestehen, einem Element oder leer sein, d.h. keine Elemente enthalten. Verwenden Sie zum Deklarieren den Operator @ (), den wir im nächsten Artikel benötigen. Dies ist sehr wichtig, um dem Array andere Arrays hinzuzufügen (mehrdimensionale Arrays zu erstellen), Arrays an Funktionen als Argumente zu übergeben und ähnliche Aufgaben:

$test_array = @() #

Wenn das Array initialisiert wird, werden seine Werte mit einem Komma (Spezialoperator) aufgelistet:

$test_array = @(1, 2, 3, 4) #

In den meisten Fällen kann der Operator @ () weggelassen werden:

$test_array = 1, 2, 3, 4

In diesem Fall wird ein Array eines Elements wie folgt initialisiert

$test_array = , 1

Für den Zugriff auf Array-Elemente werden ein ganzzahliger Index ab Null und ein Indexoperator (eckige Klammern) verwendet:

$test_array[0] = 1

Sie können mehrere durch Kommas getrennte Indizes angeben, einschließlich Duplikat:

$test_array = "", "", "", ""
$test_array[0,1,2,3]
$test_array[1,1,3,3,0]

Der Operator ..(zwei Punkte - der Bereichsoperator) gibt ein Array von Ganzzahlen in einem Segment zurück, das durch die Ober- und Untergrenze definiert ist. Beispielsweise zeigt Ausdruck 1..4 ein Array von vier Elementen @ (1, 2, 3, 4) an, und Ausdruck 8..5 zeigt ein Array @ (8, 7, 6, 5) an.

Bild

Mit dem Bereichsoperator können Sie ein Array initialisieren ($ test_array = 1..4) oder ein Slice abrufen, d. H. eine Folge von Elementen in einem Array mit Indizes von einem anderen. In diesem Fall gibt eine negative Zahl -1 das letzte Element des Arrays an, -2 - das vorletzte usw.

$test_array = "", "", "", ""
$test_array[0..2]
$test_array[2..0]
$test_array[-1..0]
$test_array[-2..1]

Bitte beachten Sie, dass die Werte des Integer-Arrays möglicherweise größer sind als der Maximalwert des Index des Datenarrays. In diesem Fall werden alle Werte bis zum letzten zurückgegeben:

$test_array[0..100]

Wenn Sie versuchen, auf ein einzelnes nicht vorhandenes Array-Element zuzugreifen, wird $ null zurückgegeben.

Bild

In PowerShell können Arrays Elemente unterschiedlichen Typs enthalten oder stark typisiert sein:

$test_array = 1, 2, "", 3, 4
for ([int]$i = 0; $i -lt $test_array.count; $i++)
{
          Write-Host $test_array[$i]
}

Dabei ist die Eigenschaft $ test_array.count die Anzahl der Elemente im Array.

Ein Beispiel für die Erstellung eines stark typisierten Arrays:

[int[]]$test_array = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9

Hash-Tabellen

Ein weiterer grundlegender Variablentyp in PowerShell sind Hash-Tabellen, die auch als assoziative Arrays bezeichnet werden. Hashtable ähnelt dem JSON-Objekt und basiert auf Schlüsselwerten. Im Gegensatz zu normalen Arrays erfolgt der Zugriff auf ihre Elemente mit benannten Schlüsseln, bei denen es sich um Objekteigenschaften handelt (Sie können auch den Indexoperator verwenden - eckige Klammern).

Eine leere Hash-Tabelle wird mit dem Service-Symbol @ und den Operator-Klammern deklariert:

$test_hashtable = @{}

Bei der Deklaration können Sie sofort Schlüssel erstellen und diesen Werte zuweisen:

$test_hashtable = @{one=""; two=""; three=""; "some key"="some value"}

Um ein Element zur Hash-Tabelle hinzuzufügen, müssen Sie ihm einen Schlüssel zuweisen, der noch nicht vorhanden ist, oder die Add () -Methode verwenden. Wenn die Zuweisung mit einem vorhandenen Schlüssel erfolgt, ändert sich dessen Wert. Verwenden Sie die Methode Remove (), um ein Element aus einer Hash-Tabelle zu entfernen.

$test_hashtable."some key"
$test_hashtable["some key"]
$test_hashtable.Add("four", "")
$test_hashtable.five = ""
$test_hashtable['five'] = " "
$test_hashtable.Remove("one")

Variablen dieses Typs können als Argumente an Funktionen und Cmdlets übergeben werden. Im nächsten Artikel erfahren Sie, wie dies funktioniert, und betrachten auch einen anderen ähnlichen Typ - PSCustomObject.

Funktionen

PowerShell verfügt über alle erforderlichen Elemente für die prozedurale Programmierung, einschließlich Funktionen. Das Funktionswort Funktion wird verwendet, um sie zu beschreiben. Danach muss der Name der Funktion und der in Operator-Klammern eingeschlossene Körper angegeben werden. Übergeben Sie gegebenenfalls Argumente an die Funktion. Sie können sie unmittelbar nach dem Namen in Klammern angeben.

function - (1, ..., N) 
{ 
        - 
}

Eine Funktion gibt immer ein Ergebnis zurück - dies ist ein Array der Ergebnisse aller ihrer Anweisungen, wenn es mehr als eine gibt. Wenn es eine Anweisung gibt, wird ein einzelner Wert des entsprechenden Typs zurückgegeben. Das Konstrukt return $ value fügt dem Ergebnisarray ein Element mit dem Wert $ value hinzu und bricht die Anweisungsliste ab. Eine leere Funktion gibt $ null zurück.

Erstellen Sie beispielsweise eine Funktion zum Quadrieren einer Zahl:

function sqr ($number)
{
      return $number * $number
}

Beachten Sie, dass Sie im Funktionskörper alle vor dem Aufruf deklarierten Variablen verwenden können und das Aufrufen von Funktionen in PowerShell ungewöhnlich erscheinen kann: Argumente (falls vorhanden) sind nicht in Klammern eingeschlossen und durch Leerzeichen getrennt.

sqr 2

oder so:

sqr -number 2

Aufgrund der Art und Weise, wie Argumente übergeben werden, muss die Funktion selbst manchmal in Klammern gesetzt werden:

function test_func ($n) {}
test_func -eq $null     #   
(test_func) -eq $null   #   — $true

Bei der Beschreibung einer Funktion können Sie den Argumenten Standardwerte zuweisen:

function func ($arg = value) {
         # 
}

Es gibt eine andere Syntax zur Beschreibung von Funktionsargumenten. Außerdem können Parameter aus der Pipeline gelesen werden. All dies wird im nächsten Artikel nützlich sein, wenn wir exportierte Module betrachten und eigene Cmdlets erstellen.

Fehlerverarbeitung

PowerShell verfügt über einen Try ... Catch ... Endlich-Mechanismus zur Behandlung von Ausnahmen. Der Try-Block enthält Code, in dem ein Fehler auftreten kann, und der Catch-Block enthält seinen Handler. Wenn kein Fehler aufgetreten ist, wird er nicht ausgeführt. Der Block "finally" wird unabhängig vom Auftreten eines Fehlers nach dem Block "Try" ausgeführt, und es können mehrere Catch-Blöcke für Ausnahmen verschiedener Typen vorhanden sein. Die Ausnahme selbst wird in die Standardvariable ohne Deklaration ($ _) geschrieben und kann problemlos abgerufen werden. Im folgenden Beispiel implementieren wir einen Schutz gegen die Eingabe eines falschen Werts:

try {

        [int]$test = Read-Host " "
        100 / $test

} catch {

         Write-Warning " "
         Write-Host $_

}

Hier geht es um die Grundlagen der PowerShell-Programmierung. In den folgenden Artikeln werden wir die Arbeit mit Variablen verschiedener Typen, Sammlungen, regulären Ausdrücken, die Erstellung von Funktionen, Modulen und benutzerdefinierten Cmdlets sowie die objektorientierte Programmierung genauer untersuchen.

Teil 1: Die Hauptfunktionen von Windows PowerShell
Teil 3: Übergeben von Parametern an Skripts und Funktionen, Erstellen von Cmdlets
Teil 4: Arbeiten mit Objekten, benutzerdefinierten Klassen

Was ist Windows PowerShell und was isst es? Teil 2: Einführung in die Programmiersprache