Co je to Windows PowerShell a s čím se jí? Část 2: Úvod do programovacího jazyka

Historicky jsou nástroje příkazového řádku na unixových systémech vyvinuty lépe než na Windows, ale s příchodem nového řešení se situace změnila.

PowerShell lze skriptovat v interpretovaném jazyce s více paradigmaty, který má prvky klasického procedurálního, objektově orientovaného a dokonce i funkčního programování: podmíněné větvení, smyčky, proměnné, pole, hashovací tabulky, třídy, zpracování chyb a také funkce, rutiny a kanály . Předchozí článek byla věnována základům práce v prostředí a nyní nabízíme našim čtenářům malou referenční knížku pro programátory.

Obsah:

Komentáře
Proměnné a jejich typy
Systémové proměnné
Rozsahy
Proměnné prostředí (prostředí)
Aritmetické a srovnávací operátory
Operátoři přiřazení
Logické operátory
Podmíněný skok
Cykly
Pole
Hash tabulky
funkce
Chyba při zpracování

Kód můžete psát v libovolném textovém editoru nebo pomocí integrovaného vývojového prostředí – nejsnazší způsob je vzít si Windows PowerShell ISE, který je dodáván se serverovými operačními systémy Microsoft. To je nutné pouze u poměrně složitých skriptů: krátké sady příkazů se snáze spouštějí interaktivně.

Komentáře

Používání komentářů je považováno za součást dobrého programovacího stylu spolu se správným odsazením a mezerami:

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

<# 

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

#>

Proměnné a jejich typy

Proměnné v PowerShellu jsou pojmenované objekty. Jejich jména mohou obsahovat znak podtržítka, stejně jako písmena a čísla. Symbol $ se vždy používá před jménem a pro deklaraci proměnné stačí dát interpretu platný název:

K inicializaci proměnné (přiřazení hodnoty k ní) se používá operátor přiřazení (symbol =):

$test = 100

Proměnnou můžete deklarovat zadáním jejího typu do hranatých závorek (operátor přetypování) před názvem nebo hodnotou:

[int]$test = 100

$test = [int]100

Je důležité pochopit, že proměnné v PowerShellu jsou plnohodnotné objekty (třídy) s vlastnostmi a metodami, jejichž typy jsou založeny na těch v .NET Core. Uvádíme ty hlavní:

Typ (třída .NET)

popis

Příklad kódu

[řetězec] System.String

Řetězec Unicode 

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

[znak]System.Char

Znak Unicode (16 bitů)

[char]$test = 'c'

[bool] System.Boolean

booleovský typ (booleovský True nebo False)

[bool]$test = $true

[int] System.Int32

třicet dva bitové celé číslo (32 bitů)

[int]$test = 123456789

[dlouhý] System.Int64

šedesát čtyři bitové celé číslo (64 bitů)

[long]$test = 12345678910

[single] System.Single

číslo s plovoucí desetinnou čárkou dlouhé 32 bitů

[jeden] $ test = 12345.6789

[double]System.Double

počet s plovoucí desetinnou čárkou, délka 64 bitů (8 bajtů)

[double] $test = 123456789.101112

[desítková]Soustava.Desetinná

128bitové číslo s plovoucí desetinnou čárkou (povinné končit na d)

[desítkové] $ test = 12345.6789d

[DateTime]System.DateTime

datum a čas 

$test = GetDate

[pole] System.Object[]

pole, jehož index prvku začíná na 0

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

[hashtable] System.Collections.Hashtable

hashovací tabulky jsou asociativní pole s pojmenovanými klíči, sestavená podle principu: @{key = "value"}

$test_hashtable = @{one="one"; two="dva"; three="tři"}

PowerShell podporuje implicitní převod typu, navíc lze typ proměnné měnit za chodu (například pomocí operátoru přiřazení), pokud není zadán vynuceně – v takovém případě interpret vypíše chybu. Typ proměnné z předchozího příkladu můžete určit voláním metody GetType():

$test.GetType().FullName

Pro manipulaci s proměnnými existuje řada rutin. Jejich seznam v pohodlné podobě se zobrazí pomocí příkazu:

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

Chcete-li zobrazit deklarované proměnné a jejich hodnoty, můžete použít speciální rutinu:

Get-Variable | more

Tato metoda se zdá příliš těžkopádná, mnohem pohodlnější je pracovat s proměnnými prostřednictvím operátorů nebo přímým přístupem k jejich vlastnostem a metodám. Rutiny však mají právo na existenci, protože umožňují nastavit některé další parametry. Je důležité pochopit, že uživatelské proměnné jsou definovány pouze v rámci aktuální relace. Po zavření konzoly nebo ukončení skriptu jsou odstraněny.

Systémové proměnné

Kromě těch, které deklaruje uživatel, existují vestavěné (systémové) proměnné, které se po skončení aktuální relace neodstraní. Jsou rozděleny do dvou typů, přičemž stavová data PowerShellu jsou uložena v automatických proměnných, kterým nelze samy o sobě přiřadit libovolné hodnoty. Patří mezi ně například $PWD:

$PWD.Path

Proměnné preferencí jsou potřebné k uložení uživatelských preferencí, jejichž hodnoty lze měnit. Například pomocí $ErrorActionPreference se nastavuje reakce interpretru příkazů na výskyt nezávažných chyb.

Kromě operátorů a cmdletů pro přístup k deklarovaným proměnným existuje proměnná: pseudoakumulátor. Můžete s ním pracovat analogicky s jinými jednotkami a proměnné v tomto případě připomínají objekty souborového systému:

Get-ChildItem Variable: | more

nebo

ls Variable: | more

Rozsahy

Pro proměnné v PowerShellu existuje koncept oboru (Scope). Akce globálního rozsahu (Global) platí pro celou aktuální relaci – zahrnuje například systémové proměnné. Lokální (místní) proměnné jsou dostupné pouze v rozsahu, kde byly definovány: řekněme uvnitř funkce. Existuje také koncept rozsahu skriptu (Script), ale u příkazů skriptu je v podstatě lokální. Ve výchozím nastavení jim při deklaraci proměnných je přidělen místní rozsah a ke změně potřebujete speciální konstrukci jako: $Global: variable = value.

Například toto:

$Global:test = 100

Proměnné prostředí (prostředí)

Další pseudo-disk, Env:, je dostupný z PowerShellu a lze jej použít pro přístup k proměnným prostředí. Když se shell spustí, jsou zkopírovány z nadřazeného procesu (tj. z programu, který zahájil aktuální relaci) a obvykle jsou jejich počáteční hodnoty stejné jako hodnoty v ovládacím panelu. Chcete-li zobrazit proměnné prostředí, použijte rutinu Get-ChildItem nebo její aliasy (aliasy): ls a dir.

dir Env:

Tyto proměnné jsou sekvence bajtů (nebo znaků, chcete-li), jejichž interpretace závisí pouze na programu, který je používá. Rutiny *-Variable nefungují s proměnnými prostředí. Chcete-li k nim přistupovat, musíte použít předponu jednotky:

$env:TEST = "Hello, World!"

Aritmetické a srovnávací operátory

PowerShell poskytuje následující aritmetické operátory: + (sčítání), - (odčítání), * (násobení), / (dělení) a % (modulo nebo modulo). Výsledek aritmetického výrazu se vyhodnocuje zleva doprava v souladu s obecně uznávaným pořadím operací a k seskupení částí výrazu se používají závorky. Mezery mezi operátory jsou ignorovány, slouží pouze k usnadnění čtení. Operátor + také zřetězí a operátor * opakuje řetězce. Pokud se pokusíte přidat číslo do řetězce, bude převedeno na řetězec. Kromě toho má jazyk PowerShell mnoho operátorů porovnání, které kontrolují shodu mezi dvěma hodnotami a vracejí logickou hodnotu True nebo False:

Provozovatel

popis

Příklad kódu

-ekv

Rovná se / rovná se (podobné = nebo == v jiných jazycích)

$ test = 100
$test -eq 123 

-narozený

Nerovná se / Nerovná se (podobně jako <> nebo !=)

$ test = 100
$test -ne 123   

-gt

Větší než / Více (analogové >)

$ test = 100
$test -gt 123

-dát

Větší nebo rovno / Větší než nebo rovno (podobné >=)

$ test = 100
$test -ge 123

-lt

Méně než / Méně (podobně jako <)

$ test = 100
$test -lt 123  

Je

Menší nebo rovno / Menší nebo rovno (podobné <=)

$ test = 100
$test -le 123

Existují další podobné operátory, které umožňují například porovnávat řetězce na základě zástupného znaku nebo používat regulární výrazy pro shodu se vzorem. Podrobně se jim budeme věnovat v dalších článcích. Symboly <, > a = se nepoužívají pro srovnání, protože se používají pro jiné účely.

Operátoři přiřazení

Kromě nejběžnějšího operátoru = existují další operátory přiřazení: +=, -=, *=, /= a %=. Před přiřazením změní hodnotu. Podobně se chovají unární operátory ++ a -, které zvyšují nebo snižují hodnotu proměnné - platí i pro operátory přiřazení.

Logické operátory

Samotné srovnání k popisu složitých podmínek nestačí. Můžete psát libovolné logické výrazy pomocí operátorů: -and, -or, -xor, -not and! .. Fungují jako v jiných programovacích jazycích, přičemž můžete pomocí závorek určit pořadí vyhodnocení:

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

-not (123 -gt 321) 

!(123 -gt 321)

Podmíněný skok

Operátory větví v PowerShellu jsou standardní: IF(IF…ELSE, IF…ELSEIF…ELSE) a SWITCH. Podívejme se na jejich použití s ​​příklady:

[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 или значение не определено"}
}

Cykly

PowerShell má několik druhů smyček: WHILE, DO WHILE, DO DOUN, FOR a FOREACH.

Smyčka s předběžnou podmínkou funguje, pokud/pokud platí:

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

Smyčky s postcondition proběhnou alespoň jednou, protože podmínka je po iteraci zkontrolována. Zároveň DO WHILE funguje, když je podmínka pravdivá, a DO DOKUD funguje, když je nepravdivá:

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

Počet iterací smyčky FOR je znám předem:

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

Ve smyčce FOREACH iteruje prvky pole nebo kolekce (hashovací tabulka):

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

Pole

Proměnné PowerShellu ukládají nejen jednotlivé objekty (číslo, řetězec atd.), ale i více objektů. Nejjednodušším druhem takových proměnných jsou pole. Pole se může skládat z několika prvků, jednoho prvku, nebo může být prázdné, tzn. neobsahují žádné prvky. Deklaruje se pomocí operátoru @(), který budeme potřebovat v dalším článku – je velmi důležitý pro přidávání dalších polí do pole (vytváření vícerozměrných polí), předávání polí funkcím jako argument a podobné úkoly:

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

Když je pole inicializováno, jeho hodnoty jsou uvedeny oddělené čárkami (speciální operátor ,):

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

Ve většině případů lze operátor @() vynechat:

$test_array = 1, 2, 3, 4

V tomto případě je pole jednoho prvku inicializováno následovně

$test_array = , 1

K prvkům pole se přistupuje pomocí celočíselného indexu založeného na nule a operátoru indexu (hranaté závorky):

$test_array[0] = 1

Můžete zadat několik indexů oddělených čárkami, vč. opakující se:

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

Provozovatel .. (dvě tečky - operátor rozsahu) vrátí pole celých čísel v rámci zadané horní a dolní meze. Například výraz 1..4 vydá pole čtyř prvků @(1, 2, 3, 4) a výraz 8..5 pole @(8, 7, 6, 5).

Pomocí operátoru range můžete inicializovat pole ($test_array = 1..4) nebo získat řez (slice), tzn. posloupnost prvků z jednoho pole s indexy z jiného. V tomto případě záporné číslo -1 označuje poslední prvek pole, -2 - předposlední atd.

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

Všimněte si, že hodnoty celočíselného pole mohou být větší než maximální hodnota indexu datového pole. V tomto případě jsou všechny hodnoty vráceny až po poslední:

$test_array[0..100]

Pokud se pokusíte o přístup k jedinému neexistujícímu prvku pole, vrátí se $null.

V PowerShellu mohou pole obsahovat prvky různých typů nebo mohou být silně zadaná:

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

Kde vlastnost $test_array.count je počet prvků pole.

Příklad vytvoření silně typovaného pole:

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

Hash tabulky

Dalším základním typem proměnných v jazyce PowerShell jsou hashovací tabulky, známé také jako asociativní pole. Hashtables jsou podobné objektům JSON a jsou vytvořeny na bázi klíč–hodnota. Na rozdíl od běžných polí se k jejich prvkům přistupuje pomocí pojmenovaných klíčů, které jsou vlastnostmi objektu (lze použít i indexový operátor – hranaté závorky).

Prázdná hashovací tabulka je deklarována pomocí symbolu @ a závorek operátoru:

$test_hashtable = @{}

Při deklaraci můžete okamžitě vytvořit klíče a přiřadit jim hodnoty:

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

Chcete-li přidat prvek do hashovací tabulky, musíte k ní přiřadit klíč, který ještě neexistuje, nebo použít metodu Add (). Pokud je přiřazení existujícímu klíči, jeho hodnota se změní. Metoda Remove() se používá k odstranění prvku z hašovací tabulky.

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

Proměnné tohoto typu lze předávat jako argumenty funkcím a cmdletům - v příštím článku se podíváme na to, jak se to dělá, a také zvážíme jiný podobný typ - PSCustomObject.

funkce

PowerShell má vše, co potřebujete pro procedurální programování, včetně funkcí. K jejich popisu se používá funkční slovo Funkce, za nímž je třeba zadat název funkce a tělo uzavřené v závorkách operátoru. Pokud potřebujete funkci předat argumenty, můžete je zadat hned za názvem v závorkách.

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

Funkce vždy vrací výsledek – je to pole výsledků všech jejích příkazů, pokud jich je více. Pokud existuje pouze jeden příkaz, je vrácena jediná hodnota odpovídajícího typu. Konstrukt return $value přidá prvek s hodnotou $hodnota do pole výsledků a přeruší provádění seznamu příkazů a prázdná funkce vrátí $null.

Vytvořme například funkci pro kvadraturu čísla:

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

Všimněte si, že v těle funkce můžete použít libovolné proměnné deklarované před jejím voláním a volání funkcí v PowerShellu se může zdát neobvyklé: argumenty (pokud existují) nejsou uzavřeny v závorkách a jsou odděleny mezerami.

sqr 2

nebo tak:

sqr -number 2

Kvůli způsobu, jakým se argumenty předávají, musí být samotná funkce někdy uzavřena v závorkách:

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

Při popisu funkce můžete argumentům přiřadit výchozí hodnoty:

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

Pro popis argumentů funkcí existuje další syntaxe, navíc lze parametry číst z pipeline – to vše se bude hodit v dalším článku, kdy se podíváme na exportované moduly a vytváření vlastních cmdletů.

Chyba při zpracování

PowerShell má mechanismus Try...Catch...Finally pro zpracování výjimek. Blok Try obsahuje kód, ve kterém může dojít k chybě, a blok Catch obsahuje jeho handler. Pokud nedošlo k chybě, neprovede se. Blok Konečně se provede po bloku Try bez ohledu na výskyt chyby a může existovat několik bloků Catch pro různé typy výjimek. Samotná výjimka je zapsána do nedeklarované výchozí proměnné ($_) a lze ji snadno získat. V níže uvedeném příkladu implementujeme ochranu proti zadání neplatné hodnoty:

try {

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

} catch {

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

}

Tímto končíme přehled základů programování v jazyce PowerShell. V následujících článcích se budeme podrobněji věnovat práci s proměnnými různých typů, kolekcím, regulárním výrazům, vytváření funkcí, modulů a vlastních cmdletů a také objektově orientovanému programování.

Zdroj: www.habr.com