Mi az a Windows PowerShell, és mivel fogyasztják? 2. rész: Bevezetés a programozási nyelvbe

Korábban a Unix rendszerek parancssori segédprogramjai jobban fejlettek, mint a Windowson, de egy új megoldás megjelenésével a helyzet megváltozott.

A PowerShell olyan értelmezett, többparadigmás nyelven írható le, amely a klasszikus procedurális, objektum-orientált, sőt funkcionális programozás elemeit is tartalmazza: feltételes elágazás, ciklusok, változók, tömbök, hash táblák, osztályok, hibakezelés, valamint függvények, parancsmagok és csővezetékek . Előző cikk a környezeti munka alapjainak szenteltük, és most egy kis programozói kézikönyvet ajánlunk olvasóinknak.

Tartalomjegyzék:

Comments
Változók és típusaik
Rendszerváltozók
Hatókör
Környezeti változók (környezet)
Aritmetikai és összehasonlító operátorok
Hozzárendelési operátorok
Logikai operátorok
Feltételes ugrás
Ciklusok
tömbök
Hash táblázatok
függvények
Hiba a feldolgozásban

Bármilyen szövegszerkesztőben vagy integrált fejlesztőkörnyezetben írhat kódot – a legegyszerűbb módja a Microsoft szerver operációs rendszereihez mellékelt Windows PowerShell ISE. Ez csak meglehetősen összetett szkripteknél szükséges: a rövid parancskészleteket könnyebb interaktívan végrehajtani.

Comments

A megjegyzések használata a megfelelő programozási stílus részének tekinthető, a megfelelő behúzással és szóközzel együtt:

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

<# 

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

#>

Változók és típusaik

A PowerShell változói elnevezett objektumok. A nevük tartalmazhatja az aláhúzás karaktert, valamint a betűket és számokat. A név előtt mindig a $ szimbólum szerepel, és egy változó deklarálásához elegendő érvényes nevet adni az értelmezőnek:

Egy változó inicializálásához (érték hozzárendeléséhez) a hozzárendelési operátort (szimbólum =) használjuk:

$test = 100

Egy változót úgy deklarálhat, hogy a név vagy érték előtt szögletes zárójelben adja meg a típusát (type casting operator):

[int]$test = 100

$test = [int]100

Fontos megérteni, hogy a PowerShell változói teljes értékű objektumok (osztályok), olyan tulajdonságokkal és metódusokkal, amelyek típusai a .NET Core-ban találhatóakon alapulnak. Felsoroljuk a főbbeket:

Típus (.NET osztály)

Leírás

Kódpélda

[karakterlánc] System.String

Unicode karakterlánc 

$teszt = "teszt"
$teszt = 'teszt'

[char]Rendszer.Char

Unicode karakter (16 bit)

[char]$test = 'c'

[bool] System.Boolean

logikai típus (logikai igaz vagy hamis)

[bool]$teszt = $igaz

[int] System.Int32

harminckét bites egész szám (32 bit)

[int]$teszt = 123456789

[hosszú] System.Int64

hatvannégy bites egész szám (64 bit)

[hosszú]$teszt = 12345678910

[egyetlen] System.Single

32 bites lebegőpontos szám

[egyetlen]$teszt = 12345.6789

[double]Rendszer.Double

lebegőpontos szám 64 bit (8 bájt)

[dupla]$teszt = 123456789.101112

[tizedes] System.Decimal

128 bites lebegőpontos szám (szükséges, hogy d-vel végződjön)

[tizedes]$teszt = 12345.6789d

[DateTime]System.DateTime

dátum és idő 

$teszt = GetDate

[tömb] System.Object[]

egy tömb, amelynek elemindexe 0-val kezdődik

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

[hashtable] System.Collections.Hashtable

A hash táblák elnevezett kulcsokkal rendelkező asszociatív tömbök, amelyek a következő elv szerint épülnek fel: @{key = "value"}

$teszt_hashtable = @{one="egy"; two="kettő"; three="három"}

A PowerShell támogatja az implicit típuskonverziót, ráadásul egy változó típusa menet közben is megváltoztatható (például hozzárendelési operátor segítségével), ha nem adjuk meg erőszakosan - ebben az esetben az értelmező hibát ad. A változó típusát az előző példából a GetType() metódus meghívásával határozhatja meg:

$test.GetType().FullName

Számos parancsmag létezik a változók kezeléséhez. Listájuk kényelmes formában a következő paranccsal jelenik meg:

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

A deklarált változók és értékeik megtekintéséhez speciális parancsmagot használhat:

Get-Variable | more

Ez a módszer túlságosan körülményesnek tűnik, sokkal kényelmesebb a változókkal operátorokon keresztül dolgozni, vagy közvetlenül hozzáférni a tulajdonságaikhoz, metódusaihoz. A parancsmagoknak azonban joguk van létezni, mert lehetővé teszik néhány további paraméter beállítását. Fontos megérteni, hogy a felhasználói változók csak az aktuális munkameneten belül vannak meghatározva. A konzol bezárásakor vagy a szkript lejártakor ezek törlődnek.

Rendszerváltozók

A felhasználó által megadottakon kívül vannak beépített (rendszer-) változók, amelyek nem törlődnek az aktuális munkamenet vége után. Két típusra oszthatók, míg a PowerShell állapotadatok automatikus változókban tárolódnak, amelyekhez önmagukban nem lehet tetszőleges értékeket rendelni. Ezek közé tartozik például a $PWD:

$PWD.Path

A felhasználói beállítások tárolásához preferenciális változókra van szükség, amelyek értéke módosítható. Például a $ErrorActionPreference használatával beállítja a parancsértelmező reakcióját a nem végzetes hibák előfordulására.

A deklarált változók elérésére szolgáló operátorokon és parancsmagokon kívül létezik egy Változó: pszeudo-akkumulátor. Más meghajtókkal analóg módon dolgozhat vele, és a változók ebben az esetben fájlrendszer-objektumokhoz hasonlítanak:

Get-ChildItem Variable: | more

vagy

ls Variable: | more

Hatókör

A PowerShell változóihoz létezik a hatókör (Scope) fogalma. A globális hatókör (Globális) művelete a teljes aktuális munkamenetre vonatkozik - például rendszerváltozókat tartalmaz. A helyi (helyi) változók csak abban a hatókörben érhetők el, ahol meghatározták őket: mondjuk egy függvényen belül. Létezik a szkript (Script) hatókörének fogalma is, de a script parancsok esetében ez alapvetően lokális. Alapértelmezés szerint a változók deklarálásakor helyi hatókört kapnak, ennek megváltoztatásához pedig egy speciális konstrukcióra van szükség, mint például: $Global: változó = érték.

Például így:

$Global:test = 100

Környezeti változók (környezet)

Egy másik pszeudo-meghajtó, az Env: elérhető a PowerShelltől, és a környezeti változók elérésére használható. Amikor a shell elindul, átmásolódnak a szülőfolyamatból (azaz az aktuális munkamenetet kezdeményező programból), és általában a kezdeti értékeik megegyeznek a vezérlőpult értékeivel. A környezeti változók megtekintéséhez használja a Get-ChildItem parancsmagot vagy annak álneveit (álneveit): ls és dir.

dir Env:

Ezek a változók bájtok (vagy karakterek, ha úgy tetszik) sorozatok, amelyek értelmezése csak az őket használó programtól függ. A *-Variable parancsmagok nem működnek a környezeti változókkal. A hozzáféréshez a meghajtó előtagját kell használnia:

$env:TEST = "Hello, World!"

Aritmetikai és összehasonlító operátorok

A PowerShell a következő aritmetikai operátorokat biztosítja: + (összeadás), - (kivonás), * (szorzás), / (osztás) és % (modulo vagy modulo). Egy aritmetikai kifejezés eredményét a rendszer balról jobbra értékeli az általánosan elfogadott műveleti sorrendnek megfelelően, és zárójeleket használ a kifejezés egyes részeinek csoportosítására. Az operátorok közötti szóközöket figyelmen kívül hagyjuk, csak az olvasás megkönnyítésére használják. A + operátor is összefűzi, a * operátor pedig megismétli a karakterláncokat. Ha megpróbál számot hozzáadni egy karakterlánchoz, a rendszer karakterláncsá alakítja. Ezenkívül a PowerShell nyelv számos összehasonlító operátorral rendelkezik, amelyek ellenőrzik a két érték közötti egyezést, és a logikai értéket igaz vagy hamis adják vissza:

operátor

Leírás

Kódpélda

-eq

Egyenlő / Egyenlő (hasonló = vagy == más nyelveken)

$teszt = 100
$teszt -eq 123 

-született

Nem egyenlő / Nem egyenlő (hasonló ehhez: <> vagy !=)

$teszt = 100
$teszt -ne 123   

-gt

Nagyobb mint / Több (analóg >)

$teszt = 100
$teszt -gt 123

-adni

Nagyobb vagy egyenlő / Nagyobb vagy egyenlő (hasonló a >=-hoz)

$teszt = 100
$teszt -ge 123

-lt

Kevesebb, mint / Kevesebb (hasonló a <-hoz)

$teszt = 100
$teszt -lt 123  

Őket

Kisebb vagy egyenlő / Kisebb vagy egyenlő (hasonló: <=)

$teszt = 100
$teszt -le 123

Vannak más hasonló operátorok is, amelyek lehetővé teszik például a karakterláncok helyettesítő karakterek alapján történő összehasonlítását, vagy reguláris kifejezések használatát a mintákhoz. A következő cikkekben részletesen foglalkozunk velük. A <, > és = szimbólumokat nem használjuk összehasonlításra, mert más célokra használják őket.

Hozzárendelési operátorok

A leggyakoribb = operátoron kívül további hozzárendelési operátorok is léteznek: +=, -=, *=, /= és %=. A hozzárendelés előtt módosítják az értéket. Hasonlóan viselkednek a ++ és - unáris operátorok is, amelyek egy változó értékét növelik vagy csökkentik - a hozzárendelési operátorokra is vonatkoznak.

Logikai operátorok

Az összehasonlítás önmagában nem elég bonyolult állapotok leírásához. Bármilyen logikai kifejezést írhat a -és, -vagy, -xor, -not and! operátorokkal.. Más programozási nyelvekhez hasonlóan működnek, míg zárójelekkel megadhatja a kiértékelés sorrendjét:

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

-not (123 -gt 321) 

!(123 -gt 321)

Feltételes ugrás

A PowerShell elágazási operátorai szabványosak: IF(IF…ELSE, IF…ELSEIF…ELSE) és SWITCH. Nézzük meg példákkal a felhasználásukat:

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

Ciklusok

A PowerShellnek többféle hurkja van: WHILE, DO WHILE, DO UNTIL, FOR és FOREACH.

Egy előfeltételes hurok akkor működik, ha/amíg igaz:

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

Az utófeltétellel rendelkező hurkok legalább egyszer lefutnak, mert a feltétel az iteráció után kerül ellenőrzésre. Ugyanakkor a DO WHILE működik, amíg a feltétel igaz, és a DO UNTIL működik, ha hamis:

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

A FOR ciklus iterációinak száma előre ismert:

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

A FOREACH ciklusban egy tömb vagy gyűjtemény (hash tábla) elemein iterál:

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

tömbök

A PowerShell-változók nem csak egyetlen objektumot (számot, karakterláncot stb.), hanem több objektumot is tárolnak. Az ilyen változók legegyszerűbb fajtái a tömbök. Egy tömb állhat több elemből, egy elemből, vagy lehet üres, pl. nem tartalmaznak elemeket. Ezt a @() operátorral deklaráljuk, amelyre a következő cikkben szükségünk lesz - nagyon fontos más tömbök hozzáadásához egy tömbhöz (többdimenziós tömbök létrehozásához), tömbök argumentumként való átadásához és hasonló feladatokhoz:

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

Egy tömb inicializálása során értékei vesszővel elválasztva jelennek meg (speciális operátor ,):

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

A legtöbb esetben a @() operátor elhagyható:

$test_array = 1, 2, 3, 4

Ebben az esetben egy elemből álló tömb inicializálása a következőképpen történik

$test_array = , 1

A tömb elemei nulla alapú egész index és az index operátor (szögletes zárójel) használatával érhetők el:

$test_array[0] = 1

Több indexet is megadhat vesszővel elválasztva, pl. ismétlődő:

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

operátor .. (két pont – tartomány operátor) egész számok tömbjét adja vissza a megadott felső és alsó határokon belül. Például az 1..4 kifejezés egy négy elemből álló tömböt ad ki @(1, 2, 3, 4), a 8..5 kifejezés pedig egy @(8, 7, 6, 5) tömböt.

A tartomány operátor segítségével inicializálhatunk egy tömböt ($teszt_tömb = 1..4), vagy kaphatunk egy szeletet (szeletet), pl. az egyik tömb elemeinek sorozata egy másik tömb indexeivel. Ebben az esetben a -1 negatív szám a tömb utolsó elemét jelöli, a -2 - az utolsó előtti, és így tovább.

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

Vegye figyelembe, hogy az egész tömb értékei nagyobbak lehetnek, mint az adattömb maximális indexértéke. Ebben az esetben az összes érték visszaadásra kerül az utolsóig:

$test_array[0..100]

Ha egyetlen, nem létező tömbelemhez próbál hozzáférni, a $null visszaadásra kerül.

A PowerShellben a tömbök különböző típusú elemeket tartalmazhatnak, vagy erősen begépelhetők:

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

Ahol a $test_array.count tulajdonság a tömbelemek száma.

Példa egy erősen beírt tömb létrehozására:

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

Hash táblázatok

A PowerShell nyelvben a változók másik alapvető típusa a hash táblák, más néven asszociatív tömbök. A hashtableok hasonlóak a JSON-objektumokhoz, és kulcs-érték alapon épülnek fel. A közönséges tömböktől eltérően ezek elemei elnevezett kulcsokkal érhetők el, amelyek az objektum tulajdonságai (az index operátort is használhatja - szögletes zárójel).

Egy üres hash tábla a @ szimbólum és a zárójelek használatával deklarálható:

$test_hashtable = @{}

Deklarációkor azonnal létrehozhat kulcsokat és értékeket rendelhet hozzájuk:

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

Ha egy elemet szeretne hozzáadni egy hash táblához, akkor hozzá kell rendelnie egy olyan kulcsot, amely még nem létezik, vagy használja a Hozzáadás () metódust. Ha egy meglévő kulcshoz hozzárendelés történik, annak értéke megváltozik. A Remove() metódus egy elem eltávolítására szolgál egy hash táblából.

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

Az ilyen típusú változók argumentumként adhatók át függvényeknek és parancsmagoknak - a következő cikkben megvizsgáljuk, hogyan történik ez, és egy másik hasonló típust is figyelembe veszünk - a PSCustomObject-et.

függvények

A PowerShell mindent tartalmaz, ami az eljárási programozáshoz szükséges, beleértve a funkciókat is. Leírásukra a Function funkciószót használjuk, amely után meg kell adni a függvény nevét és a törzset operátori zárójelek között. Ha argumentumokat kell átadnia a függvénynek, akkor azokat közvetlenül a zárójelben lévő név után adhatja meg.

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

A függvény mindig egy eredményt ad vissza – ez az összes utasításának eredményének tömbje, ha egynél több van. Ha csak egy utasítás van, akkor a megfelelő típus egyetlen értéke kerül visszaadásra. A visszatérési $value konstrukció hozzáad egy $value értékű elemet az eredménytömbhöz, és megszakítja az utasításlista végrehajtását, az üres függvény pedig $null értéket ad vissza.

Például hozzunk létre egy függvényt egy szám négyzetre emelésére:

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

Vegye figyelembe, hogy a függvény törzsében bármilyen, a hívás előtt deklarált változót használhat, és a PowerShell-beli függvények hívása szokatlannak tűnhet: az argumentumok (ha vannak) nincsenek zárójelben, és szóközzel vannak elválasztva.

sqr 2

vagy úgy:

sqr -number 2

Az argumentumok átadásának módja miatt magát a függvényt néha zárójelek közé kell tenni:

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

Egy függvény leírásakor alapértelmezett értékeket rendelhet az argumentumokhoz:

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

Van egy másik szintaxis a függvényargumentumok leírására, ezen kívül paraméterek is kiolvashatók a pipeline-ból - mindez jól jön majd a következő cikkben, amikor megnézzük az exportált modulokat és saját cmdleteket készítünk.

Hiba a feldolgozásban

A PowerShell rendelkezik egy Try...Catch...Végre mechanizmussal a kivételek kezelésére. A Try blokk tartalmazza azt a kódot, amelyben hiba fordulhat elő, a Catch blokk pedig a kezelőjét. Ha nem volt hiba, akkor nem kerül végrehajtásra. Az Végül blokk a Try blokk után fut le, függetlenül a hiba előfordulásától, és több Catch blokk is lehet a különböző típusú kivételekhez. Maga a kivétel egy nem deklarált alapértelmezett változóba ($_) van írva, és könnyen visszakereshető. Az alábbi példában védelmet valósítunk meg az érvénytelen érték megadása ellen:

try {

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

} catch {

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

}

Ezzel a PowerShell nyelvű programozás alapjainak áttekintése véget ért. A következő cikkekben részletesebben tanulmányozzuk a különböző típusú változókkal, gyűjteményekkel, reguláris kifejezésekkel való munkát, függvények, modulok és egyéni parancsmagok létrehozását, valamint az objektumorientált programozást.

Forrás: will.com