Historisch gesehen sind Befehlszeilen-Dienstprogramme auf Unix-Systemen besser entwickelt als auf Windows, aber mit der Einführung einer neuen Lösung hat sich die Situation geändert.
PowerShell kann in einer interpretierten Multi-Paradigmen-Sprache geschrieben werden, die Elemente der klassischen prozeduralen, objektorientierten und sogar funktionalen Programmierung enthält: bedingte Verzweigungen, Schleifen, Variablen, Arrays, Hash-Tabellen, Klassen, Fehlerbehandlung sowie Funktionen. Cmdlets und Pipelines. widmete sich den Grundlagen der Arbeit in der Umwelt und bietet unseren Lesern nun ein kleines Nachschlagewerk für Programmierer an.
Table of Contents:
Sie können Code in jedem Texteditor schreiben oder eine integrierte Entwicklungsumgebung verwenden – am einfachsten ist es, die Windows PowerShell ISE zu verwenden, die mit Microsoft-Serverbetriebssystemen geliefert wird. Dies ist nur bei relativ komplexen Skripten erforderlich: Kurze Befehlssätze lassen sich einfacher interaktiv ausführen.
Kommentare
Die Verwendung von Kommentaren gehört zusammen mit der richtigen Einrückung und Leerzeichen zu einem guten Programmierstil:
# Для строчных комментариев используется символ решетки — содержимое строки интерпретатор не обрабатывает.
<#
Так обозначаются начало и конец блочного комментария.
Заключенный между ними текст интерпретатор игнорирует.
#>
Variablen und ihre Typen
Variablen in PowerShell sind benannte Objekte. Ihre Namen können den Unterstrich sowie Buchstaben und Zahlen enthalten. Das $-Symbol wird immer vor dem Namen verwendet. Um eine Variable zu deklarieren, reicht es aus, dem Interpreter einen gültigen Namen zu geben:
Um eine Variable zu initialisieren (ihr einen Wert zuzuweisen), wird der Zuweisungsoperator (Symbol =) verwendet:
$test = 100Sie können eine Variable deklarieren, indem Sie ihren Typ in eckigen Klammern (Typumwandlungsoperator) vor dem Namen oder Wert angeben:
[int]$test = 100
$test = [int]100Es ist wichtig zu verstehen, dass Variablen in PowerShell vollwertige Objekte (Klassen) mit Eigenschaften und Methoden sind, deren Typen auf denen in .NET Core basieren. Wir listen die wichtigsten auf:
Typ (.NET-Klasse)
Beschreibung
Codebeispiel
[string] System.StringUnicode-Zeichenfolge
$test = "test"
$test = 'test'
Unicode-Zeichen (16 Bit)
[char]$test = 'c' [bool] System.Booleanboolescher Typ (boolescher Wert True oder False)
[bool]$test = $true [int] System.Int32Zweiunddreißig-Bit-Ganzzahl (32 Bit)
[int]$test = 123456789 [lang] System.Int6464-Bit-Ganzzahl (XNUMX Bit)
[long]$test = 12345678910 [single] System.SingleGleitkommazahl mit einer Länge von 32 Bit
[single]$test = 12345.6789 [double]System.DoubleGleitkommazahl mit einer Länge von 64 Bit (8 Byte)
[double]$test = 123456789.101112 [decimal]System.Decimal128-Bit-Gleitkommazahl (erforderlich, um mit d zu enden)
[dezimal]$test = 12345.6789d [DateTime]System.DateTimeDatum und Uhrzeit
$test = GetDate
[Array] System.Object[]ein Array, dessen Elementindex bei 0 beginnt
$test_array = 1, 2, „test“, 3, 4
[hashtable] System.Collections.HashtableHash-Tabellen sind assoziative Arrays mit benannten Schlüsseln, die nach dem Prinzip aufgebaut sind: @{key = "value"}
$test_hashtable = @{one="one"; zwei="zwei"; drei="drei"}
PowerShell unterstützt die implizite Typkonvertierung. Darüber hinaus kann der Typ einer Variablen im laufenden Betrieb geändert werden (z. B. mithilfe eines Zuweisungsoperators), wenn er nicht zwangsweise angegeben wird. In diesem Fall gibt der Interpreter einen Fehler aus. Sie können den Typ der Variablen aus dem vorherigen Beispiel ermitteln, indem Sie die Methode GetType() aufrufen:
$test.GetType().FullName
Es gibt eine Reihe von Cmdlets zum Bearbeiten von Variablen. Ihre Liste wird in praktischer Form mit dem folgenden Befehl angezeigt:
Get-Command -Noun Variable | ft -Property Name, Definition -AutoSize -Wrap
Um deklarierte Variablen und ihre Werte anzuzeigen, können Sie ein spezielles Cmdlet verwenden:
Get-Variable | moreDiese Methode erscheint übermäßig umständlich, es ist viel bequemer, mit Variablen über Operatoren zu arbeiten oder direkt auf ihre Eigenschaften und Methoden zuzugreifen. Allerdings haben Cmdlets eine Daseinsberechtigung, da sie die Möglichkeit bieten, einige zusätzliche Parameter festzulegen. Es ist wichtig zu verstehen, dass Benutzervariablen nur innerhalb der aktuellen Sitzung definiert werden. Wenn die Konsole geschlossen oder das Skript beendet wird, werden sie gelöscht.
Systemvariablen
Zusätzlich zu den vom Benutzer deklarierten Variablen gibt es integrierte (System-)Variablen, die nach 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 beliebigen Werte zugewiesen werden können. Hierzu zählen beispielsweise $PWD:
$PWD.Path
Zur Speicherung von Benutzerpräferenzen werden Präferenzvariablen benötigt, deren Werte geändert werden können. Beispielsweise wird mit $ErrorActionPreference die Reaktion des Befehlsinterpreters auf das Auftreten nicht schwerwiegender Fehler eingestellt.
Neben Operatoren und Cmdlets für den Zugriff auf deklarierte Variablen gibt es einen Variable:-Pseudoakkumulator. Sie können damit analog zu anderen Laufwerken arbeiten, und die Variablen ähneln in diesem Fall Dateisystemobjekten:
Get-ChildItem Variable: | moreoder
ls Variable: | more
Bereiche
Für Variablen in PowerShell gibt es das Konzept des Bereichs (Scope). Die Aktion des globalen Bereichs (Global) gilt für die gesamte aktuelle Sitzung – sie umfasst beispielsweise Systemvariablen. Lokale (lokale) Variablen sind nur in dem Bereich verfügbar, in dem sie definiert wurden: beispielsweise innerhalb einer Funktion. Es gibt auch das Konzept des Skriptumfangs (Skript), aber für Skriptbefehle ist es im Wesentlichen lokal. Standardmäßig erhalten Variablen beim Deklarieren einen lokalen Gültigkeitsbereich. Um dies zu ändern, benötigen Sie ein spezielles Konstrukt wie: $Global: Variable = Wert.
Zum Beispiel:
$Global:test = 100
Umgebungsvariablen (Umgebung)
Ein weiteres Pseudo-Laufwerk, Env:, ist über PowerShell verfügbar und kann für den Zugriff auf Umgebungsvariablen verwendet werden. Wenn die Shell startet, werden sie vom übergeordneten Prozess (d. h. vom Programm, das die aktuelle Sitzung initiiert hat) kopiert und normalerweise stimmen ihre Anfangswerte mit den Werten in der Systemsteuerung überein. Um Umgebungsvariablen anzuzeigen, verwenden Sie das Cmdlet Get-ChildItem oder seine Aliase (Aliase): ls und dir.
dir Env:
Diese Variablen sind Folgen von Bytes (oder Zeichen, wenn Sie so wollen), deren Interpretation nur von dem Programm abhängt, das sie verwendet. Die *-Variable-Cmdlets funktionieren nicht mit Umgebungsvariablen. Um darauf zuzugreifen, müssen Sie das Laufwerkspräfix verwenden:
$env:TEST = "Hello, World!"
Arithmetische und Vergleichsoperatoren
PowerShell bietet die folgenden arithmetischen Operatoren: + (Addition), - (Subtraktion), * (Multiplikation), / (Division) und % (Modulo oder Modulo). Das Ergebnis eines arithmetischen Ausdrucks wird von links nach rechts gemäß der allgemein anerkannten Reihenfolge der Operationen ausgewertet, und Klammern werden verwendet, um Teile des Ausdrucks zu gruppieren. Leerzeichen zwischen Operatoren werden ignoriert, sie dienen lediglich der besseren Lesbarkeit. Der +-Operator verkettet ebenfalls und der *-Operator wiederholt Zeichenfolgen. Wenn Sie versuchen, einer Zeichenfolge eine Zahl hinzuzufügen, wird diese in eine Zeichenfolge umgewandelt. Darüber hinaus verfügt die PowerShell-Sprache über viele Vergleichsoperatoren, die auf eine Übereinstimmung zwischen zwei Werten prüfen und den booleschen Wert True oder False zurückgeben:
Operator
Beschreibung
Codebeispiel
-Gl
Gleich / Gleich (ähnlich = oder == in anderen Sprachen)
$test = 100
$test -eq 123
-ne
Ungleich / Ungleich (ähnlich wie <> oder !=)
$test = 100
$test -ne 123
-GT
Größer als / Mehr (analog >)
$test = 100
$test -gt 123
-geben Sie
Größer als oder gleich / Größer als oder gleich (ähnlich wie >=)
$test = 100
$test -ge 123
-L-
Kleiner als / Kleiner (ähnlich <)
$test = 100
$test -lt 123
Le-
Kleiner als oder gleich / Kleiner als oder gleich (ähnlich wie <=)
$test = 100
$test -le 123
Es gibt andere ähnliche Operatoren, mit denen Sie beispielsweise Zeichenfolgen anhand eines Platzhalters vergleichen oder reguläre Ausdrücke verwenden können, um ein Muster abzugleichen. Wir werden sie in zukünftigen Artikeln ausführlich behandeln. Die Symbole <, > und = werden nicht zum Vergleich verwendet, da sie für andere Zwecke verwendet werden.
Zuweisungsoperatoren
Neben dem gebräuchlichsten =-Operator gibt es noch weitere 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 gelten auch für Zuweisungsoperatoren.
Logische Operatoren
Der Vergleich allein reicht nicht aus, um komplexe Sachverhalte zu beschreiben. Sie können beliebige logische Ausdrücke mit den Operatoren schreiben: -and, -or, -xor, -not und! .. Sie funktionieren wie in anderen Programmiersprachen, während Sie Klammern verwenden können, um die Reihenfolge der Auswertung festzulegen:
("Тест" -eq "Тест") -and (100 -eq 100)
-not (123 -gt 321)
!(123 -gt 321)
Bedingter Sprung
Zweigoperatoren in PowerShell sind Standard: IF(IF…ELSE, IF…ELSEIF…ELSE) und SWITCH. Schauen wir uns ihre Verwendung anhand von Beispielen an:
[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 или значение не определено"}
}
Cycles
PowerShell verfügt über mehrere Arten von Schleifen: WHILE, DO WHILE, DO UNTIL, FOR und FOREACH.
Eine Schleife mit einer Vorbedingung funktioniert, wenn/solange sie wahr ist:
[int]$test = 0
while ($test -lt 10) {
Write-Host $test
$test = $test + 1
}
Schleifen mit einer Nachbedingung werden mindestens einmal ausgeführt, da die Bedingung nach der Iteration überprüft wird. Gleichzeitig funktioniert 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 der FOR-Schleife ist im Voraus bekannt:
for ([int]$test = 0; $test -lt 10; $test++) {
Write-Host $test
}
Iteriert in der FOREACH-Schleife die Elemente eines Arrays oder einer Sammlung (Hash-Tabelle):
$test_collection = "item1", "item2", "item3"
foreach ($item in $test_collection)
{
Write-Host $item
}
Arrays
PowerShell-Variablen speichern nicht nur einzelne Objekte (Zahl, String usw.), sondern auch mehrere. Die einfachste Art solcher Variablen sind Arrays. Ein Array kann aus mehreren Elementen, einem Element oder leer sein, d. h. enthalten keine Elemente. Es wird mit dem @()-Operator deklariert, den wir im nächsten Artikel benötigen werden – er ist sehr wichtig für das Hinzufügen anderer Arrays zu einem Array (Erstellen mehrdimensionaler Arrays), die Übergabe von Arrays an Funktionen als Argument und ähnliche Aufgaben:
$test_array = @() #создаем пустой массивWenn ein Array initialisiert wird, werden seine Werte durch Kommas getrennt aufgelistet (spezieller Operator ,):
$test_array = @(1, 2, 3, 4) # создаем массив из четырех элементов 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 = , 1Der Zugriff auf Array-Elemente erfolgt über einen nullbasierten Ganzzahlindex und den Indexoperator (eckige Klammern):
$test_array[0] = 1Sie können mehrere durch Kommas getrennte Indizes angeben, inkl. wiederkehrend:
$test_array = "один", "два", "три", "четыре"
$test_array[0,1,2,3]
$test_array[1,1,3,3,0]
Operator .. (zwei Punkte – Bereichsoperator) gibt ein Array von Ganzzahlen innerhalb der angegebenen Ober- und Untergrenzen zurück. Beispielsweise gibt Ausdruck 1..4 ein Array mit vier Elementen @(1, 2, 3, 4) aus und Ausdruck 8..5 gibt ein Array @(8, 7, 6, 5) aus.
Mit dem Bereichsoperator können Sie ein Array initialisieren ($test_array = 1..4) oder ein Slice (Slice) erhalten, d. h. eine Folge von Elementen aus einem Array mit Indizes aus einem anderen. In diesem Fall bezeichnet eine negative Zahl -1 das letzte Element des Arrays, -2 das vorletzte und so weiter.
$test_array = "один", "два", "три", "четыре"
$test_array[0..2]
$test_array[2..0]
$test_array[-1..0]
$test_array[-2..1]Beachten Sie, dass ganzzahlige Array-Werte größer sein können als der maximale Indexwert 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.
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 Array-Elemente.
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 der PowerShell-Sprache sind Hash-Tabellen, auch assoziative Arrays genannt. Hashtabellen ähneln JSON-Objekten und werden auf Schlüsselwertbasis erstellt. Im Gegensatz zu gewöhnlichen Arrays erfolgt der Zugriff auf ihre Elemente über benannte Schlüssel, die Eigenschaften des Objekts sind (Sie können auch den Indexoperator in eckigen Klammern verwenden).
Eine leere Hash-Tabelle wird mit dem @-Symbol und den Operatorklammern deklariert:
$test_hashtable = @{}Bei der Deklaration können Sie sofort Schlüssel erstellen und ihnen Werte zuweisen:
$test_hashtable = @{one="один"; two="два"; three="три"; "some key"="some value"}Um ein Element zu einer Hash-Tabelle hinzuzufügen, müssen Sie ihm einen Schlüssel zuweisen, der noch nicht existiert, oder die Methode Add() verwenden. Bei einer Zuweisung zu einem bestehenden Schlüssel ändert sich dessen Wert. Die Remove()-Methode wird verwendet, 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 werden wir untersuchen, wie das geht, und auch einen anderen ähnlichen Typ betrachten – PSCustomObject.
Funktionen
PowerShell bietet alles, was Sie für die prozedurale Programmierung benötigen, einschließlich Funktionen. Um sie zu beschreiben, wird das Funktionswort Funktion verwendet. Anschließend müssen Sie den Namen der Funktion und den in Operatorklammern eingeschlossenen Text angeben. Wenn Sie Argumente an die Funktion übergeben müssen, können Sie diese direkt nach dem Namen in Klammern angeben.
function имя-функции (аргумент1, ..., аргументN)
{
тело-функции
}
Die Funktion gibt immer ein Ergebnis zurück – es ist ein Array der Ergebnisse aller ihrer Anweisungen, falls es mehr als eine gibt. Wenn es nur eine Anweisung gibt, wird der einzige Wert des entsprechenden Typs zurückgegeben. Das Konstrukt „return $value“ fügt dem Ergebnisarray ein Element mit dem Wert $value hinzu und bricht die Ausführung der Anweisungsliste ab, und die leere Funktion gibt $null zurück.
Erstellen wir zum Beispiel eine Funktion zum Quadrieren einer Zahl:
function sqr ($number)
{
return $number * $number
}
Beachten Sie, dass Sie im Hauptteil einer Funktion alle Variablen verwenden können, die vor dem Aufruf deklariert wurden. Der Aufruf von Funktionen in PowerShell kann ungewöhnlich erscheinen: Die Argumente (sofern vorhanden) stehen nicht in Klammern und werden durch Leerzeichen getrennt.
sqr 2oder so:
sqr -number 2Aufgrund der Art und Weise, wie Argumente übergeben werden, muss die Funktion selbst manchmal in Klammern eingeschlossen werden:
function test_func ($n) {}
test_func -eq $null # функция не вызывалась
(test_func) -eq $null # результат выражения — $true
Bei der Beschreibung einer Funktion können Sie Argumenten Standardwerte zuweisen:
function func ($arg = value) {
#тело функции
}
Es gibt eine andere Syntax zum Beschreiben von Funktionsargumenten, außerdem können Parameter aus der Pipeline gelesen werden – all dies wird im nächsten Artikel nützlich sein, wenn wir uns exportierte Module ansehen und unsere eigenen Cmdlets erstellen.
Fehlerbearbeitung
PowerShell verfügt über einen Try...Catch...Finally-Mechanismus zur Behandlung von Ausnahmen. Der Try-Block enthält den 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 Final-Block wird nach dem Try-Block ausgeführt, unabhängig vom Auftreten eines Fehlers, und es können mehrere Catch-Blöcke für verschiedene Arten von Ausnahmen vorhanden sein. Die Ausnahme selbst wird in eine nicht deklarierte Standardvariable ($_) geschrieben und kann leicht abgerufen werden. Im folgenden Beispiel implementieren wir einen Schutz gegen die Eingabe eines ungültigen Werts:
try {
[int]$test = Read-Host "Введите число"
100 / $test
} catch {
Write-Warning "Некорректное число"
Write-Host $_
}
Damit ist die Überprüfung der Grundlagen der Programmierung in der PowerShell-Sprache abgeschlossen. In den folgenden Artikeln werden wir uns eingehender mit der Arbeit mit Variablen verschiedener Typen, Sammlungen, regulären Ausdrücken, dem Erstellen von Funktionen, Modulen und benutzerdefinierten Cmdlets sowie der objektorientierten Programmierung befassen.
Source: habr.com