Co to jest Windows PowerShell i z czym jest spożywany? Część 2: Wprowadzenie do języka programowania

Historycznie rzecz biorąc, narzędzia wiersza poleceń w systemach Unix są lepiej rozwinięte niż w Windows, ale wraz z pojawieniem się nowego rozwiązania sytuacja się zmieniła.

PowerShell może być napisany w interpretowanym, wieloparadygmatycznym języku, który zawiera elementy klasycznego programowania proceduralnego, obiektowego, a nawet funkcjonalnego: rozgałęzienia warunkowe, pętle, zmienne, tablice, tablice skrótów, klasy, obsługę błędów, a także funkcje, polecenia cmdlet i potoki. Poprzedni artykuł poświęcony był podstawom pracy w środowisku, a teraz proponujemy naszym czytelnikom mały informator dla programistów.

Spis treści:

Komentarze
Zmienne i ich rodzaje
Zmienne systemowe
Zakresy
Zmienne środowiskowe (środowisko)
Operatory arytmetyczne i porównania
Operatory przypisania
Operatory logiczne
Skok warunkowy
Cykle
Tablice
Tabele skrótów
funkcje
Błąd przetwarzania

Możesz pisać kod w dowolnym edytorze tekstu lub przy użyciu zintegrowanego środowiska programistycznego — najłatwiej jest skorzystać z programu Windows PowerShell ISE, który jest dostarczany z serwerowymi systemami operacyjnymi firmy Microsoft. Jest to konieczne tylko w przypadku dość złożonych skryptów: krótkie zestawy poleceń są łatwiejsze do interaktywnego wykonania.

Komentarze

Używanie komentarzy jest uważane za część dobrego stylu programowania wraz z odpowiednimi wcięciami i spacjami:

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

<# 

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

#>

Zmienne i ich rodzaje

Zmienne w PowerShell to nazwane obiekty. Ich nazwy mogą zawierać znak podkreślenia, a także litery i cyfry. Symbol $ jest zawsze używany przed nazwą, a aby zadeklarować zmienną wystarczy podać interpreterowi poprawną nazwę:

Aby zainicjować zmienną (przypisać jej wartość), używany jest operator przypisania (symbol =):

$test = 100

Zmienną można zadeklarować, podając jej typ w nawiasach kwadratowych (operator rzutowania typów) przed nazwą lub wartością:

[int]$test = 100

$test = [int]100

Ważne jest, aby zrozumieć, że zmienne w PowerShell są pełnoprawnymi obiektami (klasami) z właściwościami i metodami, których typy są oparte na tych w .NET Core. Wymieniamy główne:

Typ (klasa .NET)

Opis

Przykład kodu

[ciąg] System.Ciąg

Ciąg Unicode 

$test = "test"
$test = 'test'

[char]System.Char

Znak Unicode (16 bitów)

[znak]$test = 'c'

[bool] System.Boolean

typ boolowski (boolowska prawda lub fałsz)

[bool]$test = $prawda

[int] System.Int32

trzydziestodwubitowa liczba całkowita (32 bity)

[int]$test = 123456789

[długi] System.Int64

sześćdziesięcioczterobitowa liczba całkowita (64 bity)

[długi]$test = 12345678910

[pojedynczy] System.Pojedynczy

liczba zmiennoprzecinkowa o długości 32 bitów

[pojedynczy]$test = 12345.6789

[double]System.Double

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

[podwójne]$test = 123456789.101112

[dziesiętny]System.Dziesiętny

128-bitowa liczba zmiennoprzecinkowa (wymagana na końcu d)

[dziesiętnie]$test = 12345.6789d

[DateTime]System.DateTime

data i godzina 

$test = PobierzDatę

[tablica] System.Obiekt[]

tablica, której indeks elementu zaczyna się od 0

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

[hashtable] System.Collections.Hashtable

tablice skrótów to tablice asocjacyjne z nazwanymi kluczami, zbudowane zgodnie z zasadą: @{klucz = "wartość"}

$test_hashtable = @{jeden="jeden"; dwa="dwa"; trzy="trzy"}

PowerShell obsługuje niejawną konwersję typów, ponadto typ zmiennej można zmienić w locie (na przykład za pomocą operatora przypisania), jeśli nie zostanie określony na siłę - w takim przypadku interpreter zgłosi błąd. Możesz określić typ zmiennej z poprzedniego przykładu, wywołując metodę GetType():

$test.GetType().FullName

Istnieje wiele poleceń cmdlet do manipulowania zmiennymi. Ich listę w wygodnej formie wyświetla się za pomocą polecenia:

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

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

Get-Variable | more

Ta metoda wydaje się zbyt kłopotliwa, znacznie wygodniej jest pracować ze zmiennymi za pomocą operatorów lub bezpośrednio uzyskując dostęp do ich właściwości i metod. Jednak polecenia cmdlet mają prawo istnieć, ponieważ pozwalają ustawić dodatkowe parametry. Ważne jest, aby zrozumieć, że zmienne użytkownika są definiowane tylko w ramach bieżącej sesji. Po zamknięciu konsoli lub zakończeniu skryptu są one usuwane.

Zmienne systemowe

Oprócz tych zadeklarowanych przez użytkownika, istnieją zmienne wbudowane (systemowe), które nie są usuwane po zakończeniu bieżącej sesji. Dzielą się one na dwa typy, natomiast dane stanu PowerShell są przechowywane w zmiennych automatycznych, którym nie można samodzielnie przypisać dowolnych wartości. Należą do nich na przykład $PWD:

$PWD.Path

Zmienne preferencji są potrzebne do przechowywania preferencji użytkownika, których wartości można zmieniać. Np. za pomocą $ErrorActionPreference ustawia się reakcję interpretera poleceń na wystąpienie błędów niekrytycznych.

Oprócz operatorów i poleceń cmdlet do uzyskiwania dostępu do zadeklarowanych zmiennych istnieje zmienna: pseudoakumulator. Możesz z nim pracować analogicznie z innymi dyskami, a zmienne w tym przypadku przypominają obiekty systemu plików:

Get-ChildItem Variable: | more

lub

ls Variable: | more

Zakresy

W przypadku zmiennych w PowerShell istnieje pojęcie zakresu (Scope). Akcja o zasięgu globalnym (Global) dotyczy całej bieżącej sesji - obejmuje np. zmienne systemowe. Zmienne lokalne (Lokalne) są dostępne tylko w zakresie, w którym zostały zdefiniowane: powiedzmy wewnątrz funkcji. Istnieje również koncepcja zakresu skryptu (Skrypt), ale w przypadku poleceń skryptu jest ona zasadniczo lokalna. Domyślnie podczas deklarowania zmiennych nadawany jest im zasięg lokalny, a aby to zmienić, potrzebna jest specjalna konstrukcja, taka jak: $Global: zmienna = wartość.

Na przykład tak:

$Global:test = 100

Zmienne środowiskowe (środowisko)

Inny pseudodysk, Env:, jest dostępny w PowerShell i może być używany do uzyskiwania dostępu do zmiennych środowiskowych. Podczas uruchamiania powłoki są one kopiowane z procesu nadrzędnego (czyli z programu, który zainicjował bieżącą sesję) i zwykle ich wartości początkowe są takie same jak wartości w panelu sterowania. Aby wyświetlić zmienne środowiskowe, użyj polecenia cmdlet Get-ChildItem lub jego aliasów (aliasów): ls i dir.

dir Env:

Te zmienne to sekwencje bajtów (lub znaków, jeśli wolisz), których interpretacja zależy tylko od programu, który ich używa. Polecenia cmdlet *-Variable nie działają ze zmiennymi środowiskowymi. Aby uzyskać do nich dostęp, musisz użyć prefiksu dysku:

$env:TEST = "Hello, World!"

Operatory arytmetyczne i porównania

PowerShell udostępnia następujące operatory arytmetyczne: + (dodawanie), - (odejmowanie), * (mnożenie), / (dzielenie) i % (modulo lub modulo). Wynik wyrażenia arytmetycznego jest obliczany od lewej do prawej, zgodnie z ogólnie przyjętą kolejnością działań, a nawiasy służą do grupowania części wyrażenia. Spacje między operatorami są ignorowane, służą tylko do ułatwienia czytania. Operator + również łączy, a operator * powtarza łańcuchy. Jeśli spróbujesz dodać liczbę do łańcucha, zostanie on przekonwertowany na ciąg. Ponadto język PowerShell ma wiele operatorów porównania, które sprawdzają dopasowanie między dwiema wartościami i zwracają wartość logiczną True lub False:

Operator

Opis

Przykład kodu

-równe

Równe / Równe (podobne do = lub == w innych językach)

$test = 100
$test -równ. 123 

-ne

Nierówne / Nierówne (podobne do <> lub !=)

$test = 100
$test -ne 123   

-GT

Większy niż / Więcej (analogowy >)

$test = 100
$test -gt 123

-dawać

Większy lub równy / Większy lub równy (podobny do >=)

$test = 100
$test -ge 123

-lt

Mniej niż / Mniej (podobnie jak <)

$test = 100
$test -lt 123  

Im

Mniejszy lub równy / Mniejszy lub równy (podobny do <=)

$test = 100
$test - plik 123

Istnieją inne podobne operatory, które umożliwiają na przykład porównywanie ciągów znaków na podstawie symbolu wieloznacznego lub używanie wyrażeń regularnych w celu dopasowania wzorca. Szczegółowo omówimy je w kolejnych artykułach. Symbole <, > i = nie są używane do porównania, ponieważ służą do innych celów.

Operatory przypisania

Oprócz najczęściej używanego operatora = istnieją inne operatory przypisania: +=, -=, *=, /= i %=. Zmieniają wartość przed przypisaniem. Podobnie zachowują się operatory jednoargumentowe ++ i -, które zwiększają lub zmniejszają wartość zmiennej - dotyczą również operatorów przypisania.

Operatory logiczne

Samo porównanie nie wystarczy do opisania złożonych warunków. Możesz pisać dowolne wyrażenia logiczne używając operatorów: -and, -or, -xor, -not i! .. Działają one jak w innych językach programowania, natomiast możesz użyć nawiasów, aby określić kolejność oceny:

("Тест" -eq "Тест") -and (100 -eq 100)

-not (123 -gt 321) 

!(123 -gt 321)

Skok warunkowy

Operatorami gałęzi w PowerShell są standardowe: IF(IF…ELSE, IF…ELSEIF…ELSE) i SWITCH. Spójrzmy na ich użycie 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 или значение не определено"}
}

Cykle

PowerShell ma kilka odmian pętli: WHILE, DO WHILE, DO UTIL, FOR i FOREACH.

Pętla z warunkiem wstępnym działa, jeśli/dopóki jest prawdziwa:

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

Pętle z warunkiem końcowym zostaną uruchomione przynajmniej raz, ponieważ warunek jest sprawdzany po iteracji. W tym samym czasie DO WHILE działa, gdy warunek jest prawdziwy, a DO UNTIL działa, gdy 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 pętli FOR jest z góry znana:

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

W pętli FOREACH iteruje po elementach tablicy lub kolekcji (tabela skrótów):

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

Tablice

Zmienne PowerShell przechowują nie tylko pojedyncze obiekty (liczbę, ciąg itp.), ale także wiele. Najprostszym rodzajem takich zmiennych są tablice. Tablica może składać się z kilku elementów, jednego elementu lub być pusta, tj. nie zawierać żadnych elementów. Deklaruje się ją za pomocą operatora @(), którego będziemy potrzebować w następnym artykule - jest to bardzo ważne przy dodawaniu kolejnych tablic do tablicy (tworzenie tablic wielowymiarowych), przekazywaniu tablic do funkcji jako argument i podobnych zadaniach:

$test_array = @() #создаем пустой массив

Gdy tablica jest inicjowana, jej wartości są wyświetlane oddzielone przecinkami (operator specjalny ,):

$test_array = @(1, 2, 3, 4) # создаем массив из четырех элементов 

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

$test_array = 1, 2, 3, 4

W takim przypadku tablica jednego elementu jest inicjowana w następujący sposób

$test_array = , 1

Elementy tablicy są dostępne za pomocą indeksu liczb całkowitych liczonych od zera i operatora indeksu (nawiasy kwadratowe):

$test_array[0] = 1

Możesz określić kilka indeksów oddzielonych przecinkami, m.in. powtarzający się:

$test_array = "один", "два", "три", "четыре"
$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órnych i dolnych granicach. Na przykład wyrażenie 1..4 zwraca tablicę czterech elementów @(1, 2, 3, 4), a wyrażenie 8..5 zwraca tablicę @(8, 7, 6, 5).

Za pomocą operatora range możesz zainicjować tablicę ($test_array = 1..4) lub uzyskać wycinek (wycinek), tj. sekwencja elementów z jednej tablicy z indeksami z innej. W tym przypadku liczba ujemna -1 oznacza ostatni element tablicy, -2 - przedostatni i tak dalej.

$test_array = "один", "два", "три", "четыре"
$test_array[0..2]
$test_array[2..0]
$test_array[-1..0]
$test_array[-2..1]

Należy pamiętać, że wartości tablicy liczb całkowitych mogą być większe niż maksymalna wartość indeksu tablicy danych. W takim przypadku zwracane są wszystkie wartości aż do ostatniej:

$test_array[0..100]

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

W PowerShell tablice mogą zawierać elementy różnych typów lub być silnie wpisane:

$test_array = 1, 2, "тест", 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 silnie typowanej tablicy:

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

Tabele skrótów

Innym podstawowym typem zmiennych w języku PowerShell są tablice mieszające, zwane również tablicami asocjacyjnymi. Hashtables są podobne do obiektów JSON i są zbudowane na zasadzie klucz-wartość. W przeciwieństwie do zwykłych tablic, ich elementy są dostępne za pomocą nazwanych kluczy, które są właściwościami obiektu (można też użyć operatora indeksu - nawiasów kwadratowych).

Pustą tablicę mieszającą deklaruje się za pomocą symbolu @ i nawiasów operatorskich:

$test_hashtable = @{}

Deklarując możesz od razu tworzyć klucze i przypisywać im wartości:

$test_hashtable = @{one="один"; two="два"; three="три"; "some key"="some value"}

Aby dodać element do tablicy mieszającej, należy przypisać mu klucz, który jeszcze nie istnieje, lub użyć metody Add (). Jeśli przypisanie zostanie wykonane do istniejącego klucza, jego wartość ulegnie zmianie. Metoda Remove() służy do usuwania elementu z tablicy mieszającej.

$test_hashtable."some key"
$test_hashtable["some key"]
$test_hashtable.Add("four", "четыре")
$test_hashtable.five = "пять"
$test_hashtable['five'] = "заменяем значение"
$test_hashtable.Remove("one")

Zmienne tego typu można przekazywać jako argumenty do funkcji i poleceń cmdlet - w następnym artykule przyjrzymy się, jak to się robi, a także rozważymy inny podobny typ - PSCustomObject.

funkcje

PowerShell ma wszystko, czego potrzebujesz do programowania proceduralnego, w tym funkcje. Do ich opisu używane jest słowo funkcyjne Function, po którym należy podać nazwę funkcji oraz treść ujętą w nawiasy operatorskie. Jeśli chcesz przekazać argumenty do funkcji, możesz podać je bezpośrednio po nazwie w nawiasach.

function имя-функции (аргумент1, ..., аргументN) 
{ 
        тело-функции 
} 

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

Na przykład utwórzmy funkcję podnoszącą liczbę do kwadratu:

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

Zauważ, że w ciele funkcji możesz użyć dowolnych zmiennych zadeklarowanych przed jej wywołaniem, a wywołanie funkcji w PowerShell może wydawać się niezwykłe: argumenty (jeśli są) nie są ujęte w nawiasy i są oddzielone spacjami.

sqr 2

lub tak:

sqr -number 2

Ze względu na sposób przekazywania argumentów sama funkcja czasami musi być ujęta w nawiasy:

function test_func ($n) {}
test_func -eq $null     # функция не вызывалась
(test_func) -eq $null   # результат выражения — $true

Opisując funkcję, możesz przypisać argumentom wartości domyślne:

function func ($arg = value) {
         #тело функции
}

Istnieje inna składnia opisu argumentów funkcji, dodatkowo parametry można odczytać z potoku – wszystko to przyda się w kolejnym artykule, gdy przyjrzymy się wyeksportowanym modułom i tworzeniu własnych cmdletów.

Błąd przetwarzania

Program PowerShell ma mechanizm Try...Catch...Finally do obsługi wyjątków. Blok Try zawiera kod, w którym może wystąpić błąd, a blok Catch zawiera jego procedurę obsługi. Jeśli nie wystąpił błąd, nie jest wykonywany. Blok Everything jest wykonywany po bloku Try, niezależnie od wystąpienia błędu, a dla różnych typów wyjątków może istnieć kilka bloków Catch. Sam wyjątek jest zapisywany w niezadeklarowanej zmiennej domyślnej ($_) i można go łatwo odzyskać. W poniższym przykładzie implementujemy zabezpieczenie przed wprowadzeniem nieprawidłowej wartości:

try {

        [int]$test = Read-Host "Введите число"
        100 / $test

} catch {

         Write-Warning "Некорректное число"
         Write-Host $_

}

Na tym kończymy przegląd podstaw programowania w języku PowerShell. W kolejnych artykułach zajmiemy się bardziej szczegółowo pracą ze zmiennymi różnych typów, kolekcjami, wyrażeniami regularnymi, tworzeniem funkcji, modułów i niestandardowych poleceń cmdlet, a także programowaniem obiektowym.

Źródło: www.habr.com