Történelmileg a parancssori segédprogramok a Unix rendszerekben jobban fejlődtek, mint Windows alatt, de az új megoldások megjelenésével a helyzet megváltozott.
A PowerShell esetében szkripteket egy értelmezett, több paradigma nyelven írhatunk, amely klasszikus eljáráselvű, objektum-orientált, sőt funkcionális programozási elemeket tartalmaz: feltételes ugrás, ciklusok, változók, tömbök, hash táblák, osztályok, hiba kezelés, valamint funkciók, parancsmódok és csövek. az alapvető munkafolyamatoknak volt szentelve, jelenleg pedig a programozók számára készült egy kis útmutató olvasóink figyelmébe.
Tartalomjegyzék:
A kódot bármilyen szövegszerkesztőben írhatjuk, vagy integrált fejlesztési környezet használatával — a legkönnyebb a Windows PowerShell ISE, amely a Microsoft kiszolgáló operációs rendszereinek csomagjában található. Ezt csak elég bonyolult szkriptekhez szükséges használni: rövid parancssorokat egyszerűbb interaktív módban végrehajtani.
Megjegyzések
A megjegyzések használata a jó programozási stílus részének számít a megfelelő behúzásokkal és szünetekkel együtt:
# Для строчных комментариев используется символ решетки — содержимое строки интерпретатор не обрабатывает.
<#
Так обозначаются начало и конец блочного комментария.
Заключенный между ними текст интерпретатор игнорирует.
#>
Változók és típusaik
A PowerShell-ben a változók névvel ellátott objektumok. A neveik tartalmazhatnak aláhúzási jel, betűk és számok. A név előtt mindig $ szimbólum áll, és a változó deklarálásához elegendő, ha megadjuk a fordítónak egy érvényes nevet:
A változó inicializálásához (érték hozzárendeléséhez) a hozzárendelési operátort (az = szimbólumot) használjuk:
$test = 100A változót meg lehet határozni a típusa megadásával szögletes zárójelek között (típus konvertáló operátor) a név vagy az érték előtt:
[int]$test = 100
$test = [int]100Fontos megérteni, hogy a PowerShell-ben a változók teljes értékű objektumok (osztályok), amelyek tulajdonságokkal és metódusokkal rendelkeznek, és típusuk a .NET Core folytatása. A legfontosabbakat soroljuk fel:
Típus (.NET osztály)
Leírás
Példa kódra
[string]
System.String
Unicode karakterlánc
$test = "teszt"
$test = 'teszt'
[char]
System.Char
Unicode karakter (16 bit)
[char]$test = 'c'
[bool]
System.Boolean
logikai típus (logikai érték True vagy False)
[bool]$test = $true
[int]
System.Int32
harminckét bites egész szám (32 bit)
[int]$test = 123456789
[long]
System.Int64
hatvannégy bites egész szám (64 bit)
[long]$test = 12345678910
[single]
System.Single
harminckét bites lebegőpontos szám
[single]$test = 12345.6789
[double]
System.Double
64 bites lebegőpontos szám (8 bájt)
[double]$test = 123456789.101112
[decimal]
System.Decimal
128 bites lebegőpontos szám (a végén kötelező a d megadása)
[decimal]$test = 12345.6789d
[DateTime]
System.DateTime
dátum és idő
$test = Get-Date
[array]
System.Object[]
tömb, amelynek elemeinek indexe 0-ról indul
$test_array = 1, 2, "teszt", 3, 4
[hashtable]
System.Collections.Hashtable
hash táblák — asszociatív tömbök név szerinti kulcsokkal, amelyek a következő elv szerint épülnek fel: @{kulcs = "érték"}
$test_hashtable = @{one="egy"; two="kettő"; three="három"}
A PowerShell támogatja a típusok implicit konverzióját, továbbá a változó típusa menet közben is változhat (például a hozzárendelési operátor segítségével), ha nem van kötelezően megadva — ebben az esetben az interpreter hibaüzenetet ad. Az előző példa alapján a változó típusát a GetType() metódus meghívásával lehet meghatározni:
$test.GetType().FullName 
Vannak bizonyos parancsok a változók kezelésére. A lista könnyen áttekinthető formában a következő parancs segítségével érhető el:
Get-Command -Noun Variable | ft -Property Name, Definition -AutoSize -Wrap 
A deklarált változók és értékeik megtekintésére egy speciális parancsot használhatunk:
Get-Variable | moreEz a módszer túlságosan körülményesnek tűnik, a változókkal sokkal kényelmesebb dolgozni operátorokkal vagy közvetlenül a tulajdonságaik és metódusaik elérésével. Mindazonáltal a parancsok létezésnek jogosultsága van, mivel megengedik bizonyos további paraméterek megadását. Fontos megérteni, hogy a felhasználói változók csak a jelenlegi munkamenet keretein belül vannak definiálva. A konzol bezárásával vagy a szkript végrehajtásával eltávolításra kerülnek.
Rendszerváltozók
A felhasználói által deklaráltakon kívül léteznek beépített (rendszerszintű) változók is, amelyek nem törlődnek a jelenlegi munkamenet befejezése után. Ezeket két típusra osztják, miközben a PowerShell állapotára vonatkozó adatok automatikus változókban tárolódnak, amelyeknek nem lehet önállóan tetszőleges értékeket rendelni. Ide tartozik például a $PWD:
$PWD.Path 
A felhasználói beállítások tárolására preferenciaváltozók szükségesek, amelyek értékei módosíthatók. Például a $ErrorActionPreference segítségével állítható be az interpreter reakciója a nem kritikus hibák előfordulására.
A változók eléréséhez használt operátorok és parancsok mellett létezik a Variable: álnyugágy. Ezt a többi tárolóval analógiában lehet használni, a változók ebben az esetben a fájlrendszer objektumaira emlékeztetnek:
Get-ChildItem Variable: | morevagy
ls Variable: | more 
Látókörök
A PowerShell-ben a változóknak hatáskör fogalmuk van. A globális hatáskör (Global) az aktuális munkamenetre terjed ki — ide tartoznak például a rendszerváltozók. A lokális (Local) változók csak abban a hatáskörben érhetők el, ahol definiálták őket: mondjuk egy funkción belül. Van egy szkript hatáskör (Script) fogalom is, de parancsok esetén lényegében lokálisnak számít. Alapértelmezés szerint a változók deklarálásakor lokális hatáskört kapnak, és ennek megváltoztatásához speciális szintaxis szükséges: $Global: változó = érték.
Például így:
$Global:test = 100
Környezeti változók
A PowerShell-ből egy másik álnyugágy is elérhető, az Env:, amely segítségével elérhetjük a környezeti változókat. Amikor az elemző elindul, ezek a szülő folytatásból (azaz a jelenlegi munkamenetet kezdeményező programból) másolódnak, és általában a kezdeti értékeik megegyeznek a vezérlőpult értékeivel. A környezeti változók megtekintéséhez a Get-ChildItem parancsot vagy annak álnév (alias) parancsait, mint az ls és dir, használják.
dir Env: 
Ezek a változók bájtok (vagy karakterek) sorozatai, melyek értelmezését csak az őket használó program határozza meg. Az *-Variable parancsok nem működnek a környezeti változókkal. Az elérésükhöz lemez előtagot kell használni:
$env:TEST = "Hello, World!" 
Aritmetikai operátorok és összehasonlító operátorok
A PowerShellben az alábbi aritmetikai operátorok találhatók: + (összeadás), — (kivonás), * (szorzás), / (osztás) és % (maradékos osztás). Az aritmetikai kifejezés eredménye balról jobbra a megszokott műveleti sorrend szerint számítódik ki, míg a kifejezés részeinek csoportosításához zárójeleket használnak. Az operátorok közötti szóközöket figyelmen kívül hagyják, azok csupán a könnyebb értelmezés érdekében vannak. A + operátor szövegeket is egyesít, a * operátor pedig megszorozza a szövegeket. Amikor egy számot próbálnak hozzáadni egy szöveghez, a szám átalakul szöveggé. Ezen kívül a PowerShell nyelvben számos összehasonlító operátor található, amelyek két érték közötti megfelelést ellenőriznek, és logikai True vagy False értéket adnak vissza:
Operátor
Leírás
Példa kódra
-eq
Egyenlő / Equals (analóg a = vagy == más nyelvekben)
$test = 100
$test -eq 123
-ne
Nem egyenlő / Not equal (analóg vagy !=)
$test = 100
$test -ne 123
-gt
Nagyobb mint / Greater than (analóg >)
$test = 100
$test -gt 123
-ge
Nagyobb vagy egyenlő / Greater than or equal (analóg >=)
$test = 100
$test -ge 123
-lt
Kisebb mint / Less than (analóg <)
$test = 100
$test -lt 123
-le
Kisebb vagy egyenlő / Less than or equal (analóg <=)
$test = 100
$test -le 123
Más hasonló operátorok is léteznek, amelyek például lehetővé teszik a szövegek összehasonlítását helyettesítő karakterek figyelembevételével, vagy reguláris kifejezések használatával kereshetik a mintákhoz való illeszkedést. Ezeket a következő cikkekben részletesen megvizsgáljuk. A és = jeleket nem használják az összehasonlításra, mivel más célokra van szükség rájuk.
Hozzárendelési operátorok
A legelterjedtebb = operátor mellett léteznek más hozzárendelő operátorok is: +=, -=, *=, /= és %= . Ezek megváltoztatják az értéket a hozzárendelés előtt. Hasonlóan viselkednek az együttes operátorok ++ és —, amelyek növelik vagy csökkentik a változó értékét — ezek is hozzárendelő operátorok.
Logikai operátorok
Bonyolult feltételek leírásához a puszta összehasonlítás nem elegendő. Bármilyen logikai kifejezést a következő operátorok segítségével is fel lehet írni: -and, -or, -xor, -not és !... Ugyanúgy működnek, mint más programozási nyelvekben, és használhatók zárójelek a számítási sorrend megadására:
("Teszt" -eq "Teszt") -and (100 -eq 100)
-not (123 -gt 321)
!(123 -gt 321)
Feltételes ugrás
A PowerShellben a feltételes elágazások szabványosak: IF(IF…ELSE, IF…ELSEIF…ELSE) és SWITCH. Vizsgáljuk meg használatukat példákon keresztül:
[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 5 vagy az érték nincs meghatározva"}
}
Ciklusok
A PowerShell nyelvben többféle ciklus létezik: WHILE, DO WHILE, DO UNTIL, FOR és FOREACH.
A feltételes ciklus működik, ha/amíg ez teljesül:
[int]$test = 0
while ($test -lt 10) {
Write-Host $test
$test = $test + 1
}
A posztfeltételes ciklusok legalább egyszer végrehajtódnak, mert a feltétel ellenőrzése az iteráció végrehajtása után történik. A DO WHILE addig működik, amíg a feltétel igaz, míg a DO UNTIL az ellenkező esetben:
[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 ciklus egy tömb vagy gyűjtemény (hash tábla) elemeit iterálja:
$test_collection = "item1", "item2", "item3"
foreach ($item in $test_collection)
{
Write-Host $item
}
Tömbök
A PowerShell változók nemcsak egyedi objektumokat (mint például szám, szöveg, stb.) tárolnak, hanem többet is. A legbasicabb változattípusuk a tömbök. A tömb állhat több elemből, egyetlen elemből vagy lehet üres, azaz nem tartalmaz elemeket. Kinyilatkoztatásához az @() operátort használják, amely a következő cikkben nagyon fontos lesz, mivel szükség lesz más tömbök hozzáadására (többdimenziós tömbök létrehozásához), valamint tömbök átadására függvényeknek argumentumként és hasonló feladatokhoz:
$test_array = @() # üres tömb létrehozásaA tömb inicializálásakor az értékek vesszővel vannak felsorolva (speciális operátor, ,):
$test_array = @(1, 2, 3, 4) # négy elemű tömb létrehozása A legtöbb esetben az @() operátor elhagyható:
$test_array = 1, 2, 3, 4Ebben az esetben az egy elemű tömb inicializálása a következőképpen történik
$test_array = , 1A tömb elemeinek eléréséhez egy nulláról induló egész számú indexet és az indexelési operátort (szögletes zárójelek) használunk:
$test_array[0] = 1Több indexet is meg lehet adni vízszintesen, beleértve az ismétlődő indexeket is:
$test_array = "egy", "kettő", "három", "négy"
$test_array[0,1,2,3]
$test_array[1,1,3,3,0] 
Operátor .. (két pont — intervallum operátor) visszaad egy egész számokból álló tömböt egy adott felső és alsó határon belül. Például az 1..4 kifejezés egy négy elemből álló tömböt eredményez @(1, 2, 3, 4), míg a 8..5 kifejezés egy @(8, 7, 6, 5) tömböt ad vissza.
Az intervallum operátor segítségével inicializálható egy tömb ($test_array = 1..4), vagy egy szelet (slice) kapható, azaz egy tömb egyes elemeinek sorrendje egy másik tömb indexei alapján. Ekkor a -1 negatív szám az utolsó tömb elemet, a -2 a péntelet követőt jelöli, és így tovább.
$test_array = "egy", "kettő", "három", "négy"
$test_array[0..2]
$test_array[2..0]
$test_array[-1..0]
$test_array[-2..1]Vegye figyelembe, hogy az egész számokból álló tömb értékei lehetnek nagyobbak, mint a tömb maximális indexe. Ebben az esetben az utolsó elemig visszaadja az összes értéket:
$test_array[0..100]Ha megpróbál hozzáférni egy nem létező tömb elemhez, akkor a $null értéket kapja.
A PowerShell-ben a tömbök tartalmazhatnak különböző típusú elemeket, vagy lehetnek szigorúan típusúak:
$test_array = 1, 2, "teszt", 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ömb elemeinek számát jelenti.
Példa egy szigorúan típusú tömb létrehozására:
[int[]]$test_array = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
Hash táblák
A PowerShell nyelvben egy másik alapvető típus az hash-táblák, amelyeket asszociatív tömböknek is neveznek. A Hashtable hasonlít a JSON objektumhoz, és kulcs-érték elv szerint épül fel. A hagyományos tömböktől eltérően az elemekhez név szerinti kulcsokkal férünk hozzá, amelyek az objektum tulajdonságai (index operátor — négyzetes zárójelek is használhatók).
Egy üres hash-tábla a @ segédszimbólum és az operátoros zárójelek segítségével deklarálható:
$test_hashtable = @{}Deklaráláskor azonnal létrehozhatók kulcsok és rendelhetők hozzájuk értékek:
$test_hashtable = @{one="egy"; two="kettő"; three="három"; "some key"="some value"}Egy elem hozzáadásához a hash-táblához egy még nem létező kulcsot kell hozzárendelni, vagy az Add() metódust kell használni. Ha létező kulcshoz rendeljük, annak értéke megváltozik. Az elem eltávolítására a hash-táblából a Remove() metódus használható.
$test_hashtable."some key"
$test_hashtable["some key"]
$test_hashtable.Add("four", "négy")
$test_hashtable.five = "öt"
$test_hashtable['five'] = "érték cseréje"
$test_hashtable.Remove("one") 
Ezeket a típusú változókat át lehet adni funkcióknak és parancsnak - a következő cikkben megvizsgáljuk, hogyan működik ez, és foglalkozunk egy hasonló típussal is - PSCustomObject.
Funkciók
A PowerShell nyelv tartalmaz minden szükséges elemet a procedurális programozáshoz, beleértve a funkciókat is. A funkciók leírásához a Function kulcsszót használjuk, amelyet a funkció neve és a paraméterek zárójelek közé írott törzse követ.
function funkcio-nev (argument1, ..., argumentN)
{
funkcio-torzs
}
A funkció mindig visszaad egy eredményt - ez az összes állításának tömbje, ha több mint egy van. Ha csupán egy állítás van, akkor egyetlen értéket ad vissza a megfelelő típusban. A return $value szerkezet egy elemet ad hozzá az eredmények tömbjéhez, amelynek értéke $value, és megszakítja az utasítássorozat végrehajtását, míg egy üres funkció $null-t ad vissza.
Például hozzunk létre egy funkciót, amely egy szám négyzetre emelését végzi:
function sqr ($szam)
{
return $szam * $szam
}
Megjegyezzük, hogy a funkció törzsében bármilyen, a hívás előtt deklarált változót használhatunk, és a PowerShell funkcióinak hívása szokatlannak tűnhet: az argumentumok (ha vannak) nem zárójelek között, hanem szóközökkel elválasztva kerülnek megadásra.
sqr 2vagy így:
sqr -szam 2Az argumentumok átadásának módja miatt néha magát a funkciót is zárójelek közé kell tenni:
function test_func ($n) {}
test_func -eq $null # a funkció nem volt meghívva
(test_func) -eq $null # a kifejezés eredménye - $true 
A funkció leírása során alapértelmezett értékeket is rendelhetünk az argumentumokhoz:
function func ($arg = value) {
#funkcio-torzs
}
Van egy másik szintaxis is a funkcióargumentumok leírására, ráadásul a paraméterek olvashatók a csővezetékből is - mindez hasznos lesz a következő cikkben, amikor az exportálási modulokat és a saját parancsok létrehozását vizsgáljuk.
Hibakezelés
A PowerShellben létezik a Try…Catch…Finally mechanizmus, amely lehetővé teszi a kivételi helyzetek kezelését. A Try blokkba kerül az a kód, amelyben hiba merülhet fel, míg a Catch blokk az annak kezelője. Ha nem történt hiba, a Catch blokk nem hajtódik végre. A Finally blokk mindig végrehajtódik a Try blokk után, függetlenül attól, hogy történt-e hiba, és több Catch blokk is létezhet különböző típusú kivételekhez. Maga a kivétel egy előzetesen deklarálás nélküli változóba ($_) kerül, és könnyen kinyerhető. Az alábbi példában a nem megfelelő érték bevitelének védelmét valósítjuk meg:
try {
[int]$test = Read-Host "Kérem, írjon be egy számot"
100 / $test
} catch {
Write-Warning "Hibás szám"
Write-Host $_
}
Ezen a ponton befejeződik a PowerShell programozás alapjainak bemutatása. A következő cikkekben részletesebben megvizsgáljuk a különböző típusú változók kezelését, a gyűjteményeket, a reguláris kifejezéseket, a funkciók, modulok és saját parancskészletek létrehozását, valamint az objektumorientált programozást.
Forrás: habr.com
