Historisch gesehen sind die Befehlszeilenhilfsprogramme in Unix-Systemen besser entwickelt als in Windows. Mit der Einführung neuer Lösungen hat sich die Situation jedoch geändert.
Für PowerShell können Skripte in einer interpretierbaren, multiparadigmatischen Sprache geschrieben werden, die Elemente der klassischen prozeduralen, objektorientierten und sogar funktionalen Programmierung umfasst: bedingte Verzweigungen, Schleifen, Variablen, Arrays, Hash-Tabellen, Klassen, Fehlerbehandlung sowie Funktionen, Cmdlets und Pipelines. war den Grundlagen der Arbeit in der Umgebung gewidmet, und jetzt bieten wir den Lesern ein kleines Handbuch für Programmierer an.
Inhaltsverzeichnis:
Code kann in jedem Texteditor oder unter Verwendung einer integrierten Entwicklungsumgebung geschrieben werden – am einfachsten ist es, Windows PowerShell ISE aus dem Lieferumfang der Serverbetriebssysteme von Microsoft zu verwenden. Dies ist nur für ausreichend komplexe Skripte erforderlich: Kurze Befehlssätze lassen sich einfacher im interaktiven Modus ausführen.
Kommentare
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 das Unterstrichzeichen sowie Buchstaben und Zahlen enthalten. Vor dem Namen wird immer das Zeichen $ verwendet, und um eine Variable zu deklarieren, genügt es, dem Interpreter einen zulässigen Namen anzugeben:
Zur Initialisierung einer Variablen (Zuweisung eines Wertes) wird der Zuweisungsoperator (Symbol =) verwendet:
$test = 100Eine Variable kann auch angegeben werden, indem ihr Typ in eckigen Klammern (Typumwandlungsoperator) vor dem Namen oder dem Wert angegeben wird:
[int]$test = 100
$test = [int]100Es ist wichtig zu verstehen, dass Variablen in PowerShell vollständige Objekte (Klassen) mit Eigenschaften und Methoden sind, deren Typen auf den in .NET Core vorhandenen basieren. Die wichtigsten sind:
Typ (Klasse .NET)
Beschreibung
Beispielcode
[string]
System.String
Unicode-Zeichenfolge
$test = «тест»
$test = ‘тест’
[char]
System.Char
Unicode-Zeichen (16 Bit)
[char]$test = ‘c’
[bool]
System.Boolean
Boolescher Typ (logischer Wert True oder False)
[bool]$test = $true
[int]
System.Int32
32-Bit-Ganzzahl (32 Bit)
[int]$test = 123456789
[long]
System.Int64
64-Bit-Ganzzahl (64 Bit)
[long]$test = 12345678910
[single]
System.Single
32-Bit-Gleitkommazahl
[single]$test = 12345.6789
[double]
System.Double
Gleitkommazahl mit einer Länge von 64 Bit (8 Byte)
[double]$test = 123456789.101112
[decimal]
System.Decimal
Gleitkommazahl mit einer Länge von 128 Bit (d muss am Ende angegeben werden)
[decimal]$test = 12345.6789d
[DateTime]
System.DateTime
Datum und Uhrzeit
$test = Get-Date
[array]
System.Object[]
Array, dessen Elemente bei 0 indiziert werden
$test_array = 1, 2, "test", 3, 4
[hashtable]
System.Collections.Hashtable
Hashtables – assoziative Arrays mit benannten Schlüsseln, die nach dem Prinzip @{Schlüssel = "Wert"} aufgebaut sind.
$test_hashtable = @{one="eins"; two="zwei"; three="drei"}
PowerShell unterstützt implizite Typumwandlungen, außerdem kann der Typ einer Variable dynamisch geändert werden (z. B. mithilfe des Zuweisungsoperators), wenn er nicht ausdrücklich angegeben wird – in diesem Fall wird ein Fehler vom Interpreter ausgegeben. Der Typ der Variable aus dem vorherigen Beispiel kann durch den Aufruf der Methode GetType() bestimmt werden:
$test.GetType().FullName 
Es gibt eine Vielzahl von Cmdlets zur Verwaltung von Variablen. Ihre Liste wird in kompakter Form mit dem Befehl ausgegeben:
Get-Command -Noun Variable | ft -Property Name, Definition -AutoSize -Wrap 
Um die deklarierten Variablen und deren Werte anzuzeigen, kann ein spezielles Cmdlet verwendet werden:
Get-Variable | moreDiese Methode erscheint als übermäßig umständlich, es ist einfacher, mit Variablen über Operatoren oder durch direkten Zugriff auf deren Eigenschaften und Methoden zu arbeiten. Dennoch haben Cmdlets ihre Berechtigung, da sie einige zusätzliche Parameter ermöglichen. Es ist wichtig zu verstehen, dass benutzerdefinierte Variablen nur im aktuellen Sitzungskontext definiert sind. Nach Schließen der Konsole oder Beenden des Skripts werden sie gelöscht.
Systemvariablen
Neben benutzerdeklarierten Variablen gibt es auch systeminterne (eingebaute) Variablen, die nach Beendigung der aktuellen Sitzung nicht gelöscht werden. Sie werden in zwei Typen unterteilt, wobei die Informationen über den Zustand von PowerShell in automatischen Variablen gespeichert werden, denen keine willkürlichen Werte zugewiesen werden können. Dazu gehört beispielsweise $PWD:
$PWD.Path 
Zur Speicherung benutzerdefinierter Einstellungen sind die Preferenzvariablen erforderlich, deren Werte geändert werden können. Beispielsweise wird mithilfe von $ErrorActionPreference die Reaktion des Befehlsinterpreters auf das Auftreten von nicht kritischen Fehlern festgelegt.
Zusätzlich zu Operatoren und Cmdlets zur Ansprache der deklarierten Variablen gibt es einen Pseudoloader Variable:. Man kann damit analog zu anderen Loaders arbeiten, wobei Variablen in diesem Fall Objekten des Dateisystems ähneln:
Get-ChildItem Variable: | mehroder
ls Variable: | mehr 
Geltungsbereiche
Für Variablen in PowerShell gibt es das Konzept des Gültigkeitsbereichs (Scope). Die globale Reichweite (Global) gilt für die gesamte aktuelle Sitzung — dazu gehören beispielsweise Systemvariablen. Lokale (Local) Variablen sind nur in dem Bereich verfügbar, in dem sie definiert wurden: sagen wir innerhalb einer Funktion. Es gibt auch das Konzept des Skriptbereichs (Script), aber für Skriptbefehle ist es im Grunde genommen lokal. Standardmäßig wird beim Deklarieren von Variablen deren Gültigkeitsbereich lokal gesetzt, und um das zu ändern, ist eine spezielle Konstruktion erforderlich: $Global: variable = wert.
Zum Beispiel so:
$Global:test = 100
Umgebungsvariablen
Aus PowerShell ist ein weiterer Pseudoloader Env: verfügbar, mit dem man auf Umgebungsvariablen zugreifen kann. Bei der Ausführung der Shell werden sie aus dem übergeordneten Prozess kopiert (d. h. aus dem Programm, das die aktuelle Sitzung initiiert hat) und in der Regel stimmen ihre ursprünglichen Werte mit den Werten in der Systemsteuerung überein. Zur Anzeige der Umgebungsvariablen werden die Cmdlets Get-ChildItem oder deren Aliase (Aliasnamen) verwendet: ls und dir.
dir Env: 
Diese Variablen bestehen aus Bytefolgen (oder Zeichen, wenn Sie so wollen), deren Interpretation nur von dem verwendenden Programm abhängt. Cmdlets *-Variable funktionieren nicht mit Umgebungsvariablen. Um auf sie zuzugreifen, muss man das Laufwerkspräfix verwenden:
$env:TEST = "Hallo, Welt!" 
Arithmetische Operatoren und Vergleichsoperatoren
In PowerShell gibt es folgende mathematische Operatoren: + (Addition), — (Subtraktion), * (Multiplikation), / (Division) und % (Modul oder Rest der Division). Das Ergebnis eines mathematischen Ausdrucks wird von links nach rechts gemäß der allgemein anerkannten Reihenfolge der Operationen berechnet, wobei runde Klammern zur Gruppierung von Teilen des Ausdrucks verwendet werden. Leerzeichen zwischen den Operatoren werden ignoriert und dienen nur zur besseren Lesbarkeit. Der Operator + verbindet auch, während der Operator * Strings wiederholt. Wenn man versucht, eine Zahl zu einem String hinzuzufügen, wird sie in eine String umgewandelt. Außerdem gibt es in PowerShell eine Vielzahl von Vergleichsoperatoren, die die Übereinstimmung zwischen zwei Werten überprüfen und logische Werte True oder False zurückgeben:
Operator
Beschreibung
Beispielcode
-eq
Gleich / Entspricht (entspricht = oder == in anderen Sprachen)
$test = 100
$test -eq 123
-ne
Nicht gleich / Ungleich (entspricht oder !=)
$test = 100
$test -ne 123
-gt
Größer als / Größer (entspricht >)
$test = 100
$test -gt 123
-ge
Größer oder gleich / Größer oder gleich (entspricht >=)
$test = 100
$test -ge 123
-lt
Weniger als / Kleiner (entspricht <)
$test = 100
$test -lt 123
-le
Weniger als oder gleich / Kleiner oder gleich (entspricht <=)
$test = 100
$test -le 123
Es gibt auch andere ähnliche Operatoren, die es beispielsweise ermöglichen, Strings mit Berücksichtigung von Platzhaltern zu vergleichen oder reguläre Ausdrücke zu verwenden, um Übereinstimmungen mit Mustern zu finden. Diese werden wir in den nächsten Artikeln ausführlich behandeln. Die Zeichen und = werden für den Vergleich nicht verwendet, da sie für andere Zwecke genutzt werden.
Zuweisungsoperatoren
Neben dem gebräuchlichsten Operator = gibt es auch andere Zuweisungsoperatoren: +=, -=, *=, /= und %= . Sie ändern den Wert vor der Zuweisung. Ähnlich verhalten sich die unären Operatoren ++ und —, die den Wert einer Variablen erhöhen oder verringern — sie gehören ebenfalls zu den Zuweisungsoperatoren.
Logische Operatoren
Um komplizierte Bedingungen zu beschreiben, reicht ein einfacher Vergleich nicht aus. Es können beliebige logische Ausdrücke mit den Operatoren: -and, -or, -xor, -not und !… gebildet werden. Sie funktionieren wie in anderen Programmiersprachen und es können runde Klammern verwendet werden, um die Reihenfolge der Berechnung festzulegen:
("Test" -eq "Test") -and (100 -eq 100)
-not (123 -gt 321)
!(123 -gt 321)
Bedingte Verzweigung
Die Verzweigungsoperatoren in PowerShell sind Standard: IF(IF…ELSE, IF…ELSEIF…ELSE) und SWITCH. Lassen Sie uns deren Einsatz anhand von Beispielen betrachten:
[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 5 oder Wert nicht definiert"}
}
Schleifen
In der PowerShell-Sprache gibt es verschiedene Arten von Schleifen: WHILE, DO WHILE, DO UNTIL, FOR und FOREACH.
Eine Schleife mit Vorbedingung funktioniert, wenn/soweit sie erfüllt ist:
[int]$test = 0
while ($test -lt 10) {
Write-Host $test
$test = $test + 1
}
Nachbedingungen-Schleifen werden mindestens einmal ausgeführt, da die Bedingungsprüfung nach der Ausführung der Iteration erfolgt. Dabei läuft DO WHILE, solange die Bedingung wahr ist, und DO UNTIL, solange sie 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 in der FOR-Schleife ist im Voraus bekannt:
for ([int]$test = 0; $test -lt 10; $test++) {
Write-Host $test
}
In der FOREACH-Schleife erfolgt die Durchlauf über die Elemente eines Arrays oder einer Sammlung (Hash-Tabellen):
$test_collection = "item1", "item2", "item3"
foreach ($item in $test_collection)
{
Write-Host $item
}
Arrays
In PowerShell-Variablen können nicht nur einzelne Objekte (Zahl, Zeichenfolge usw.) gespeichert werden, sondern auch mehrere. Die einfachste Variante dieser Variablen sind Arrays. Ein Array kann aus mehreren Elementen, aus einem Element oder leer sein, d.h. keine Elemente enthalten. Zur Deklaration wird der Operator @() verwendet, der uns im nächsten Artikel wichtig sein wird – er ist sehr wichtig für das Hinzufügen anderer Arrays zu einem Array (zum Erstellen von mehrdimensionalen Arrays), das Übergeben von Arrays an Funktionen als Argument und ähnlichen Aufgaben:
$test_array = @() #wir erstellen ein leeres ArrayBei der Initialisierung eines Arrays werden die Werte durch Kommas (spezieller Operator ,) aufgezählt:
$test_array = @(1, 2, 3, 4) # wir erstellen ein Array aus vier Elementen In den meisten Fällen kann der Operator @() weggelassen werden:
$test_array = 1, 2, 3, 4In diesem Fall wird ein Array mit einem Element wie folgt initialisiert:
$test_array = , 1Zum Zugriff auf die Elemente eines Arrays wird ein nullbasiertes Ganzzahlindex und der Indizierungsoperator (eckige Klammern) verwendet:
$test_array[0] = 1Es können mehrere Indizes durch Kommas angegeben werden, einschließlich wiederholter:
$test_array = "eins", "zwei", "drei", "vier"
$test_array[0,1,2,3]
$test_array[1,1,3,3,0] 
Operator .. (zwei Punkte – Bereichsoperator) gibt ein Array von Ganzzahlen innerhalb einer bestimmten oberen und unteren Grenze zurück. Zum Beispiel gibt der Ausdruck 1..4 ein Array mit vier Elementen @(1, 2, 3, 4) aus, während der Ausdruck 8..5 das Array @(8, 7, 6, 5) zurückgibt.
Mit dem Bereichsoperator kann ein Array initialisiert werden ($test_array = 1..4) oder ein Slice, d.h. eine Sequenz von Elementen eines Arrays mit Indizes aus einem anderen, erhalten werden. Dabei bedeutet die negative Zahl -1 das letzte Element des Arrays, -2 das vorletzte usw.
$test_array = "eins", "zwei", "drei", "vier"
$test_array[0..2]
$test_array[2..0]
$test_array[-1..0]
$test_array[-2..1]Bitte beachten Sie, dass die Werte des Ganzzahlenarrays größer sein können als der maximale Wert des Array-Indexes mit Daten. In diesem Fall werden alle Werte bis zum letzten zurückgegeben:
$test_array[0..100]Wenn man versucht, auf ein einzelnes nicht existierendes Element im Array zuzugreifen, wird der Wert $null zurückgegeben.
In PowerShell können Arrays Elemente verschiedener Typen enthalten oder strikt typisiert sein:
$test_array = 1, 2, "Test", 3, 4
for ([int]$i = 0; $i -lt $test_array.count; $i++)
{
Write-Host $test_array[$i]
}
Wobei die Eigenschaft $test_array.count die Anzahl der Elemente im Array darstellt.
Beispiel zur Erstellung eines strikt 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 assoziative Arrays genannt werden. Hashtables ähneln einem JSON-Objekt und werden nach dem Prinzip Schlüssel-Wert strukturiert. Im Gegensatz zu normalen Arrays erfolgt der Zugriff auf deren Elemente über benannte Schlüssel, die Eigenschaften eines Objekts sind (man kann auch den Indexoperator – eckige Klammern – verwenden).
Eine leere Hash-Tabelle wird mit dem Dienstsymbol @ und geschweiften Klammern deklariert:
$test_hashtable = @{}Beim Deklarieren können Sie sofort Schlüssel erstellen und ihnen Werte zuweisen:
$test_hashtable = @{one="eins"; two="zwei"; three="drei"; "some key"="some value"}Um ein Element zur Hash-Tabelle hinzuzufügen, müssen Sie einen noch nicht existierenden Schlüssel zuweisen oder die Methode Add() verwenden. Wenn die Zuweisung mit einem bestehenden Schlüssel erfolgt, ändert sich dessen Wert. Zum Entfernen eines Elements aus der Hash-Tabelle wird die Methode Remove() verwendet.
$test_hashtable."some key"
$test_hashtable["some key"]
$test_hashtable.Add("four", "vier")
$test_hashtable.five = "fünf"
$test_hashtable['five'] = "Wert ersetzen"
$test_hashtable.Remove("one") 
Variablen dieses Typs können als Argumente an Funktionen und Cmdlets übergeben werden – im nächsten Artikel werden wir studieren, wie dies geschieht, und außerdem einen weiteren ähnlichen Typ betrachten: PSCustomObject.
Funktionen
In der Programmiersprache PowerShell gibt es alle notwendigen Elemente für die prozedurale Programmierung, einschließlich Funktionen. Zur Beschreibung dieser Funktionen wird das Schlüsselwort Function verwendet, gefolgt von dem Namen der Funktion und dem in geschweifte Klammern eingeschlossenen Körper. Wenn Argumente an die Funktion übergeben werden müssen, können diese direkt nach dem Namen in runden Klammern angegeben werden.
function funktionsname (argument1, ..., argumentN)
{
funktionskörper
}
Eine Funktion gibt immer ein Ergebnis zurück – dies ist ein Array von Ergebnissen aller ihrer Anweisungen, wenn mehr als eine vorhanden ist. Wenn nur eine Anweisung existiert, wird ein einzelner Wert des entsprechenden Typs zurückgegeben. Die Konstruktion return $value fügt ein Element mit dem Wert $value zum Ergebnisarray hinzu und unterbricht die Ausführung der Anweisungsliste, während eine leere Funktion $null zurückgibt.
Zum Beispiel erstellen wir eine Funktion, die eine Zahl quadriert:
function sqr ($number)
{
return $number * $number
}
Es ist zu beachten, dass im Funktionskörper beliebige zuvor deklarierte Variablen verwendet werden können, und der Funktionsaufruf in PowerShell kann ungewohnt erscheinen: Argumente (sofern vorhanden) werden nicht in runde Klammern gesetzt und durch Leerzeichen getrennt.
sqr 2oder so:
sqr -number 2Aufgrund der Methode zur Übergabe von Argumenten muss die Funktion manchmal in Klammern gesetzt werden:
function test_func ($n) {}
test_func -eq $null # Funktion wurde nicht aufgerufen
(test_func) -eq $null # Ergebnis des Ausdrucks — $true 
Beim Beschreiben einer Funktion können Standardwerte an die Argumente zugewiesen werden:
function func ($arg = value) {
#funktionskörper
}
Es gibt auch eine andere Syntax zur Beschreibung von Funktionen, außerdem können Parameter aus der Pipeline gelesen werden – all dies wird im nächsten Artikel nützlich sein, wenn wir exportierbare Module und die Erstellung eigener Cmdlets behandeln.
Fehlerbehandlung
In PowerShell gibt es einen Mechanismus namens Try…Catch…Finally, der es ermöglicht, Ausnahmebedingungen zu behandeln. Im Try-Block wird der Code platziert, in dem ein Fehler auftreten kann, und im Catch-Block befindet sich der Fehlerbehandler. Wenn kein Fehler auftritt, wird dieser Block nicht ausgeführt. Der Finally-Block wird nach dem Try-Block unabhängig von der Fehlerentstehung ausgeführt, und es kann mehrere Catch-Blöcke für verschiedene Ausnahmearten geben. Die Ausnahme selbst wird in der standardmäßig nicht deklarierten Variablen ($_) gespeichert und kann leicht extrahiert werden. Im folgenden Beispiel implementieren wir einen Schutz gegen die Eingabe eines ungültigen Wertes:
try {
[int]$test = Read-Host "Geben Sie eine Zahl ein"
100 / $test
} catch {
Write-Warning "Ungültige Zahl"
Write-Host $_
}
Hiermit beenden wir die Einführung in die Programmierung mit PowerShell. In den folgenden Artikeln werden wir die Arbeit mit Variablen verschiedener Typen, Sammlungen, regulären Ausdrücken, die Erstellung von Funktionen, Modulen und eigenen Cmdlets sowie die objektorientierte Programmierung eingehender betrachten.
Quelle: habr.com
