Co to jest Windows PowerShell i jak to działa? Część 2: wprowadzenie do języka programowania

Historycznie, narzędzia wiersza poleceń w systemach Unix zostały rozwinięte lepiej niż w Windows, jednak wraz z pojawieniem się nowego rozwiązania sytuacja uległa zmianie.

PowerShell pozwala pisać skrypty w interpretowanym języku wieloparadygmatowym, który łączy elementy klasycznego programowania proceduralnego, obiektowego, a nawet funkcyjnego: instrukcje warunkowe, pętle, zmienne, tablice, tablice asocjacyjne, klasy, obsługa błędów oraz funkcje, cmdlety i potoki. Poprzedni artykuł była poświęcona podstawom pracy w środowisku, a teraz oferujemy czytelnikom mały poradnik dla programistów.

Spis treści:

Komentarze
Zmienne i ich typy
Zmienne systemowe
Zakresy widoczności
Zmienne środowiskowe
Operatory arytmetyczne i operatory porównania
Operatory przypisania
Operatory logiczne
Instrukcja warunkowa
Pętle
Tablice
Tablice asocjacyjne
Funkcje
Obsługa błędów

Kod można pisać w dowolnym edytorze tekstu lub używając zintegrowanego środowiska programistycznego — najprościej wziąć Windows PowerShell ISE z zestawu dostarczanego z systemami operacyjnymi serwerów Microsoft. To konieczne jedynie dla wystarczająco skomplikowanych skryptów: krótkie zestawy komend łatwiej wykonywać w trybie interaktywnym.

Komentarze

Korzystanie z komentarzy jest uważane za element dobrego stylu programowania, obok odpowiednich wcięć i spacji:

# Для строчных комментариев используется символ решетки — содержимое строки интерпретатор не обрабатывает.

<# 

       Так обозначаются начало и конец блочного комментария. 
       Заключенный между ними текст интерпретатор игнорирует.

#>

Zmienne i ich typy

Zmienne w PowerShell to obiekty z nazwami. Ich nazwy mogą zawierać znak podkreślenia, a także litery i cyfry. Przed nazwą zawsze używa się znaku $, a aby zadeklarować zmienną, wystarczy podać interpreterowi poprawną nazwę:

Do inicjalizacji zmiennej (przypisania jej wartości) używa się operatora przypisania (znak =):

$test = 100

Można zadeklarować zmienną z określeniem jej typu w kwadratowych nawiasach (operator rzutowania typów) przed nazwą lub wartością:

[int]$test = 100

$test = [int]100

Ważne jest, aby zrozumieć, że zmienne w PowerShell to pełnoprawne obiekty (klasy) z właściwościami i metodami, których typy bazują na tych z .NET Core. Wymieńmy podstawowe:

Typ (klasa .NET)

Opis

Przykład kodu

[string]
System.String

ciąg Unicode 

$test = „test”
$test = ‘test’

[char]
System.Char

znak Unicode (16 bitów)

[char]$test = ‘c’

[bool]
System.Boolean

typ boolowski (wartość logiczna True lub False)

[bool]$test = $true

[int]
System.Int32

liczba całkowita 32-bitowa

[int]$test = 123456789

[long]
System.Int64

liczba całkowita 64-bitowa

[long]$test = 12345678910

[single]
System.Single

liczba zmiennoprzecinkowa 32-bitowa

[single]$test = 12345.6789

[double]
System.Double

liczba zmiennoprzecinkowa o długości 64 bitów (8 bajtów)

[double]$test = 123456789.101112

[decimal]
System.Decimal

liczba zmiennoprzecinkowa o długości 128 bitów (należy dodać d na końcu)

[decimal]$test = 12345.6789d

[DateTime]
System.DateTime

data i czas 

$test = Get-Date

[array]
System.Object[]

tablica, indeks elementów zaczyna się od 0

$test_array = 1, 2, "test", 3, 4

[hashtable]
System.Collections.Hashtable

tablice haszujące — tablice asocjacyjne z nazwanymi kluczami, zbudowane w ten sposób: @{klucz = "wartość"}

$test_hashtable = @{one="jeden"; two="dwa"; three="trzy"}

PowerShell wspiera implicitne konwersje typów, ponadto typ zmiennej może zmieniać się dynamicznie (na przykład poprzez operator przypisania), jeśli nie jest określony na sztywno — w takim przypadku interpreter zgłosi błąd. Typ zmiennej z poprzedniego przykładu można ustalić używając metody GetType():

$test.GetType().FullName

Istnieje określona liczba poleceń do zarządzania zmiennymi. Ich lista w wygodnej formie wyświetlana jest za pomocą polecenia:

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

Aby wyświetlić zadeklarowane zmienne i ich wartości, można użyć specjalnego polecenia:

Get-Variable | more

Taki sposób wydaje się nadmiernie złożony, z zmiennymi znacznie łatwiej pracować za pomocą operatorów albo bezpośrednio odnosząc się do ich właściwości i metod. Niemniej polecenia mają prawo bytu, ponieważ pozwalają ustawić pewne dodatkowe parametry. Ważne jest zrozumienie, że zmienne użytkownika są zdefiniowane tylko w zakresie bieżącej sesji. Po zamknięciu konsoli lub zakończeniu skryptu są usuwane.

Zmienne systemowe

Oprócz zadeklarowanych przez użytkownika istnieją wbudowane (systemowe) zmienne, które nie są usuwane po zakończeniu bieżącej sesji. Dzielą się na dwa typy, a dane o stanie PowerShell są przechowywane w zmiennych automatycznych, którym nie można samodzielnie przyporządkować dowolnych wartości. Do ich liczby należy na przykład $PWD:

$PWD.Path

Do przechowywania ustawień użytkowników potrzebne są zmienne preferencji, których wartości można zmieniać. Na przykład przy pomocy $ErrorActionPreference określa się reakcję interpretera na wystąpienie niekrytycznych błędów.

Oprócz operatorów i poleceń do odwoływania się do zadeklarowanych zmiennych istnieje pseudozbiornik Variable:. Można z nim pracować analogicznie do innych zbiorników, a zmienne w tym przypadku przypominają obiekty systemu plików:

Get-ChildItem Variable: | more

lub

ls Variable: | more

Zakresy widoczności

Dla zmiennych w PowerShell istnieje pojęcie zakresu (Scope). Działanie zakresu globalnego (Global) rozciąga się na całą bieżącą sesję — obejmuje na przykład zmienne systemowe. Zmienne lokalne (Local) są dostępne tylko w zakresie, w którym zostały zadeklarowane: na przykład wewnątrz funkcji. Istnieje jeszcze pojęcie zakresu skryptu (Script), ale dla poleceń skryptowych jest on w zasadzie lokalny. Domyślnie przy deklarowaniu zmiennych przypisuje się im lokalny zakres, a aby to zmienić, potrzebna jest specjalna konstrukcja typu: $Global: zmienna = wartość.

Na przykład tak:

$Global:test = 100

Zmienne środowiskowe

Z PowerShell dostępny jest jeszcze jeden pseudozbiornik Env:, za pomocą którego można odwołać się do zmiennych środowiskowych. Przy uruchomieniu powłoki są one kopiowane z procesu macierzystego (tj. z programu inicjującego bieżącą sesję) i zwykle ich początkowe wartości są zgodne z wartościami w panelu sterowania. Aby wyświetlić zmienne środowiskowe, można użyć polecenia Get-ChildItem lub jego aliasów: ls oraz dir.

dir Env:

Te zmienne reprezentują ciągi bajtów (lub znaków, jeśli preferujesz), a ich interpretacja zależy wyłącznie od programu, który je wykorzystuje. Polecenia *-Variable nie działają z zmiennymi środowiskowymi. Aby się do nich odwołać, trzeba użyć prefiksu dysku:

$env:TEST = "Hello, World!"

Operatory arytmetyczne i operatory porównania

W PowerShell dostępne są następujące operatory arytmetyczne: + (dodawanie), — (odejmowanie), * (mnożenie), / (dzielenie) oraz % (modulo lub reszta z dzielenia). Wynik wyrażenia arytmetycznego obliczany jest od lewej do prawej zgodnie z powszechnie przyjętą kolejnością działań, a do grupowania części wyrażenia używane są nawiasy. Spacje między operatorami są ignorowane, używa się ich jedynie dla ułatwienia percepcji. Operator + łączy również, a operator * powiela ciągi. Podczas próby dodania liczby do ciągu, liczba zostanie przekształcona w ciąg. Ponadto w języku PowerShell istnieje wiele operatorów porównania, które sprawdzają zgodność między dwiema wartościami i zwracają logiczne True lub False:

Operator

Opis

Przykład kodu

-eq

Równy / Equal (odpowiednik = lub == w innych językach)

$test = 100
$test -eq 123 

-ne

Różny / Not equal (odpowiednik lub !=)

$test = 100
$test -ne 123   

-gt

Większy / Greater than (odpowiednik >)

$test = 100
$test -gt 123

-ge

Większy lub równy / Greater than or equal (odpowiednik >=)

$test = 100
$test -ge 123

-lt

Mniejszy / Less than (odpowiednik <)

$test = 100
$test -lt 123  

-le

Mniejszy lub równy / Less than or equal (odpowiednik <=)

$test = 100
$test -le 123

Istnieją także inne podobne operatory, które pozwalają na przykład na porównywanie ciągów z uwzględnieniem symbolu zastępczego lub wykorzystanie wyrażeń regularnych do znajdowania zgodności ze wzorcem. Omówimy je szczegółowo w następnych artykułach. Symbole i = do porównania nie są używane, ponieważ służą innym celom.

Operatory przypisania

Oprócz najpowszechniej używanego operatora = istnieją także inne operatory przypisania: +=, -=, *=, /= oraz %= . Zmieniają one wartość przed przypisaniem. Podobnie działają operatory unarne ++ i —, które zwiększają lub zmniejszają wartość zmiennej — również są one operatorami przypisania.

Operatory logiczne

Aby opisać złożone warunki, same porównania są niewystarczające. Dowolne wyrażenia logiczne można zapisywać za pomocą operatorów: -and, -or, -xor, -not oraz !. Działają one jak w innych językach programowania, przy czym można używać nawiasów, aby określić kolejność obliczeń:

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

-not (123 -gt 321) 

!(123 -gt 321)

Instrukcja warunkowa

Operatory warunkowe w PowerShell są standardowe: IF(IF…ELSE, IF…ELSEIF…ELSE) i SWITCH. Przyjrzyjmy się ich zastosowaniu na przykładach:

[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 lub wartość nieokreślona"}
}

Pętle

W języku PowerShell istnieje kilka rodzajów pętli: WHILE, DO WHILE, DO UNTIL, FOR i FOREACH.

Pętla warunkowa działa, gdy lub dopóki jest spełniona:

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

Pętle z postwarunkiem wykonywane są przynajmniej raz, ponieważ sprawdzenie warunku następuje po wykonaniu iteracji. W tym przypadku DO WHILE działa, dopóki warunek jest prawdziwy, a DO UNTIL — dopóki jest fałszywy:

[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)

Liczba iteracji w pętli FOR jest znana z góry:

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

W pętli FOREACH odbywa się iteracja po elementach tablicy lub kolekcji (tablicy haszującej):

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

Tablice

W zmiennych PowerShell można przechowywać nie tylko pojedyncze obiekty (liczby, ciągi itd.), lecz także wiele z nich. Najprostszym rodzajem takich zmiennych są tablice. Tablica może składać się z kilku elementów, jednego elementu lub być pusta, tzn. nie zawierać elementów. Do jej deklaracji używamy operatora @(), który będzie nam potrzebny w następnym artykule — jest bardzo ważny do dodawania innych tablic do tablicy (tworzenia tablic wielowymiarowych), przekazywania tablic do funkcji jako argumenty i podobnych zadań:

$test_array = @() # tworzymy pustą tablicę

Podczas inicjowania tablicy jej wartości są wymieniane przez przecinek (specjalny operator ,):

$test_array = @(1, 2, 3, 4) # tworzymy tablicę z czterema elementami 

W większości przypadków operator @() można pominąć:

$test_array = 1, 2, 3, 4

W takim przypadku tablica składająca się z jednego elementu jest inicjowana w następujący sposób:

$test_array = , 1

Aby uzyskać dostęp do elementów tablicy, używamy indeksu całkowitego zaczynającego się od zera oraz operatora indeksowania (nawiasy kwadratowe):

$test_array[0] = 1

Można podać kilka indeksów oddzielonych przecinkiem, w tym powtarzających się:

$test_array = "jeden", "dwa", "trzy", "cztery"
$test_array[0,1,2,3]
$test_array[1,1,3,3,0]

Operator .. (dwie kropki — operator zakresu) zwraca tablicę liczb całkowitych w określonych górnej i dolnej granicy zakresu. Na przykład, wyrażenie 1..4 zwraca tablicę czterech elementów @(1, 2, 3, 4), a wyrażenie 8..5 — tablicę @(8, 7, 6, 5).

Za pomocą operatora zakresu można inicjalizować tablicę ($test_array = 1..4) lub uzyskiwać wycinki (slice), tzn. sekwencję elementów jednej tablicy z indeksami z innej. Przy czym liczba ujemna -1 oznacza ostatni element tablicy, -2 — przedostatni itd.

$test_array = "jeden", "dwa", "trzy", "cztery"
$test_array[0..2]
$test_array[2..0]
$test_array[-1..0]
$test_array[-2..1]

Zauważ, że wartości tablicy liczb całkowitych mogą być większe niż maksymalna wartość indeksu tablicy z danymi. W takim przypadku zwracane są wszystkie wartości do ostatniej:

$test_array[0..100]

Jeśli spróbujesz uzyskać dostęp do jedynego nieistniejącego elementu tablicy, zwracana jest wartość $null.

W PowerShell tablice mogą zawierać elementy różnych typów lub być ściśle typowane:

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

Gdzie właściwość $test_array.count to liczba elementów tablicy.

Przykład tworzenia ściśle typowanej tablicy:

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

Tablice asocjacyjne

Innym podstawowym typem zmiennych w języku PowerShell są tablice asocjacyjne, które nazywane są także haszami. Hashtable przypomina obiekt JSON i jest budowana na zasadzie klucz-wartość. W odróżnieniu od zwykłych tablic, dostęp do ich elementów odbywa się za pomocą nazwanych kluczy, które są właściwościami obiektu (można również używać operatora indeksu — nawiasów kwadratowych).

Pustą tablicę asocjacyjną deklaruje się za pomocą symbolu służbowego @ i nawiasów operatorowych:

$test_hashtable = @{}

Podczas deklaracji można od razu tworzyć klucze i przypisywać im wartości:

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

Aby dodać element do tablicy asocjacyjnej, należy przypisać jej jeszcze nieistniejący klucz lub skorzystać z metody Add(). Jeśli przypisanie odbywa się z istniejącym kluczem, jego wartość zostanie zmieniona. Aby usunąć element z tablicy asocjacyjnej, użyj metody Remove().

$test_hashtable."some key"
$test_hashtable["some key"]
$test_hashtable.Add("four", "cztery")
$test_hashtable.five = "pięć"
$test_hashtable['five'] = "zmieniamy wartość"
$test_hashtable.Remove("one")

Zmienne tego typu można przekazywać jako argumenty do funkcji i komend — w następnym artykule omówimy, jak to działa oraz przyjrzymy się innemu podobnemu typowi — PSCustomObject.

Funkcje

W języku PowerShell znajdują się wszystkie niezbędne elementy do programowania proceduralnego, w tym funkcje. Do ich opisu używa się słowa kluczowego Function, po którym należy podać nazwę funkcji oraz otoczone nawiasami jej ciało. W razie potrzeby przekazania argumentów do funkcji, można je wskazać od razu po nazwie w nawiasach.

function nazwa-funkcji (argument1, ..., argumentN) 
{ 
        ciało-funkcji 
} 

Funkcja zawsze zwraca wynik — jest to tablica wyników wszystkich jej instrukcji, jeśli ich jest więcej niż jedna. Jeśli jest tylko jedna instrukcja, zwracana jest pojedyncza wartość odpowiedniego typu. Konstrukcja return $value dodaje element o wartości $value do tablicy wyników i przerywa wykonanie listy instrukcji, a pusta funkcja zwraca $null.

Na przykład stwórzmy funkcję podnoszenia liczby do kwadratu:

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

Zauważmy, że w ciele funkcji można używać dowolnych zmiennych zadeklarowanych przed jej wywołaniem, a wywołania funkcji w PowerShell mogą wydawać się niecodzienne: argumenty (jeśli są) nie są umieszczane w nawiasach i są oddzielane spacjami.

sqr 2

lub tak:

sqr -number 2

Z powodu sposobu przekazywania argumentów samą funkcję czasami trzeba umieścić w nawiasach:

function test_func ($n) {}
test_func -eq $null     # funkcja nie została wywołana
(test_func) -eq $null   # wynik wyrażenia — $true

Podczas opisywania funkcji można przypisać argumentom wartości domyślne:

function func ($arg = value) {
         #ciało funkcji
}

Istnieje także inna składnia do opisu argumentów funkcji, ponadto parametry mogą być odczytywane z potoku — wszystko to przyda się w następnym artykule, gdy będziemy omawiać eksportowane moduły i tworzenie własnych komend.

Obsługa błędów

W PowerShell istnieje mechanizm Try…Catch…Finally, który umożliwia obsługę sytuacji wyjątkowych. W bloku Try umieszczany jest kod, w którym może wystąpić błąd, a w bloku Catch – jego obsługa. Jeżeli błędu nie było, blok Catch nie jest wykonywany. Blok Finally jest wykonywany po bloku Try, niezależnie od wystąpienia błędu, a bloków Catch może być kilka dla wyjątków różnych typów. Same wyjątki są zapisywane w nie wymagającej deklaracji zmiennej domyślnej ($_) i mogą być łatwo wydobywane. W poniższym przykładzie realizujemy ochronę przed wprowadzeniem niepoprawnej wartości:

try {

        [int]$test = Read-Host "Wprowadź liczbę"
        100 / $test

} catch {

         Write-Warning "Niepoprawna liczba"
         Write-Host $_

}

Na tym kończymy przedstawienie podstaw programowania w PowerShell. W następnych artykułach przyjrzymy się bliżej pracy z zmiennymi różnych typów, kolekcjami, wyrażeniami regularnymi, tworzeniem funkcji, modułów i własnych cmdletów, a także programowaniu obiektowemu.

Źródło: habr.com