Ajalooliselt on Unix-süsteemide käsurea tööriistad paremini arenenud kui Windowsis, kuid uue lahenduse ilmumisega on olukord muutunud.
PowerShellis saab kirjutada skripte tõlgendatavas mitme paradigma keeles, mis sisaldab elemente klassikalisest protseduurilisest, objekti-orienteeritud ja isegi funktsionaalsest programmeerimisest: tingimuslikud üleminekud, silmused, muutujad, massiivid, hash-tabelid, klassid, vigade käsitsemine ning samuti funktsioonid, cmdlet'id ja torud. oli pühendatud keskkonna töö alustele ning nüüd pakume lugejatele väikest juhendit programmeerijatele.
Sisukord:
Koodi saab kirjutada igas tekstiredaktoris või kasutades integreeritud arenduskeskkonda — kõige lihtsam on võtta Windows PowerShell ISE, mis kuulub Microsofti serverite operatsioonisüsteemide komplekti. Seda on vaja ainult piisavalt keerukate skriptide jaoks: lühikesi käskude komplekte on lihtsam täita interaktiivselt.
Kommentaarid
Kommentaaride kasutamine loetakse osaks heast programmeerimisstiilist koos õige vahe ja tühikutega:
# Для строчных комментариев используется символ решетки — содержимое строки интерпретатор не обрабатывает.
<#
Так обозначаются начало и конец блочного комментария.
Заключенный между ними текст интерпретатор игнорирует.
#>
Muutujad ja nende tüübid
Muuttajad PowerShellis on nimelised objektid. Nende nimed võivad sisaldada allajoonimisnumbrit, samuti tähti ja numbreid. Nime ees on alati märk $, ning muutuja deklareerimiseks piisab, kui anda tõlgile sobiv nimi:
Muuttuja initsialiseerimiseks (temale väärtuse määramiseks) kasutatakse määramise operaatorit (märk =):
$test = 100Muuttujat saab deklareerida, määrates tema tüübi ruudukujuliste sulgudega (tüübimuutmise operaator) nime või väärtuse ette:
[int]$test = 100
$test = [int]100Oluline on mõista, et PowerShellis on muuttajad täisväärtuslikud objektid (klassid), millel on omadused ja meetodid, mille tüübid põhinevad .NET Core'is olevatel. Loetleme peamised:
Tüüp (klass .NET)
Kirjeldus
Koodinäide
[string]
System.String
Unicode string
$test = «test»
$test = ‘test’
[char]
System.Char
Unicode symbol (16 bitti)
[char]$test = ‘c’
[bool]
System.Boolean
boolean tüüp (loogiline väärtus True või False)
[bool]$test = $true
[int]
System.Int32
kolmekümne kahebitine terviknumber (32 bitti)
[int]$test = 123456789
[long]
System.Int64
kuuekümne nelja bitine terviknumber (64 bitti)
[long]$test = 12345678910
[single]
System.Single
ujuv punkt nummer 32 biti pikkusega
[single]$test = 12345.6789
[double]
System.Double
u jumal punkt nummer 64 biti pikkusega (8 baiti)
[double]$test = 123456789.101112
[decimal]
System.Decimal
u jumal punkt nummer 128 biti pikkusega (peab olema d lõpuks)
[decimal]$test = 12345.6789d
[DateTime]
System.DateTime
kuupäev ja aeg
$test = Get-Date
[array]
System.Object[]
massiiv, mille elementide indeks algab nullist
$test_array = 1, 2, «test», 3, 4
[hashtable]
System.Collections.Hashtable
hash-tabelid — assotsiatiivsed massiivid nimega võtmetega, loodud põhimõttel: @{võti = «väärtus»}
$test_hashtable = @{one=«üks»; two=«kaks»; three=«kolm»}
PowerShell toetab vaikimisi tüübi teisendamist ja muutuvate tüüpide kasutamist, kui seda ei ole sunnitud määratud — sellisel juhul annab tõlgendaja vea. Eelmise näite muutujatüübi määramiseks saab kasutada meetodi GetType() kutsumist:
$test.GetType().FullName 
Muutujate haldamiseks on olemas teatud arv käsklusi. Nende nimekirja kuvatakse mugaval kujul käsu abil:
Get-Command -Noun Variable | ft -Property Name, Definition -AutoSize -Wrap 
Deklaritud muutujate ja nende väärtuste vaatamiseks saab kasutada spetsiaalset käsku:
Get-Variable | moreSee meetod tundub liiga keeruline, samuti on palju mugavam töötada muutujate kaudu operaatorite või otse nende omaduste ja meetodite kaudu. Siiski on käsklustel oma koht, kuna need võimaldavad määrata täiendavaid parameetreid. Oluline on mõista, et kasutaja määratud muutujad on kehtivad ainult praeguses seansis. Pärast konsooli sulgemist või skripti lõpetamist kustutatakse need.
Süsteemimuutujad
Lisaks kasutaja poolt määratud muutujaitele eksisteerivad süsteemsed (süsteemi) muutujad, mis ei kao praeguse sessiooni lõppedes. Need jagunevad kaheks tüübiks, kusjuures PowerShelli olekuandmeid hoitakse automaatsetes muutujates, millele ei saa omistada omavoli väärtusi. Nende hulka kuuluvad näiteks $PWD:
$PWD.Path 
Kasutaja seadete salvestamiseks on vajalikud eelistuste muutujad, mille väärtusi saab muuta. Näiteks määrab $ErrorActionPreference tõlgendi reageering mitte-kriitiliste vigade tekkimisele.
Lisaks operaatoritele ja käskudele on kuulutatud muutujaitele ligipääsemiseks pseudokogum Variable:. Sellega töötamine sarnaneb teiste kogumitega ning sel juhul meenutavad muutujad failisüsteemi objekte:
Get-ChildItem Variable: | morevõi
ls Variable: | more 
Nähtusala
PowerShellis on olemas mõisted ulatusest (Scope). Globaalne ulatus (Global) kehtib kogu jooksva sessiooni jooksul — see hõlmab näiteks süsteemimuutujaid. Kohalikud (Local) muutujad on saadaval ainult ulatuses, kus nad on määratletud, näiteks funktsiooni sees. On ka skripti ulatuse (Script) mõisted, kuid skripti käskude puhul on see põhimõtteliselt kohalik. Vaikimisi määratakse muutujaid deklareerides neile kohalik ulatus, ja kui seda muuta, on vajalik eriline konstruktsioon, mille vorm on: $Global: muutuja = väärtus.
Näiteks nii:
$Global:test = 100
Keskkonnamuutujad
PowerShellis on veel üks psedo-ühend Env:, mille abil saab ligi keskkonna muutujatele. Kui kest käivitatakse, kopeeritakse need vanemprotsessist (st programm, mis alustas jooksva seansi) ja nende algsed väärtused vastavad tavaliselt juhtpaneeli väärtustele. Keskkonna muutujaid saab vaadata käsku Get-ChildItem või selle psedoonüüde (alias): ls ja dir.
dir Env: 
Needle lõike on byte'ide (või sümbolite, kui soovite) järjestused, mille tõlgendus sõltub vaid neid kasutavatest programmidest. Kommando *-Variable keskkonnamuutujate puhul ei tööta. Neile viitamiseks on vaja kasutada ketta prefiksit:
$env:TEST = "Hello, World!" 
Aritmeetilised operaatorid ja võrdlusoperaatorid
PowerShellis on järgmised数学istatud operaatorid: + (liitmine), — (lahutamine), * (korrutamine), / (jagatamine) ja % (modulatsioon või jääk). Arvutuste tulemusi arvutatakse vasakult paremale vastavalt üldtunnustatud tehete järjekorrale ja väljendi osade rühmitamiseks kasutatakse kaarlinge. Operatoorite vahelised tühikud jäetakse tähelepanuta, neid kasutatakse ainult arusaadavuse hõlbustamiseks. Operaator + ühendab ka ja operaator * kordab tekste. Kui proovite liita arvu tekstiga, muudetakse see tekstiks. Samuti on PowerShelli keeles palju võrdlusoperaatoreid, mis kontrollivad kahe väärtuse vastavust ja tagastavad loogilised True või False:
Operaator
Kirjeldus
Koodinäide
-eq
Equal / Võrdub (sarnane = või == teiste keeltes)
$test = 100
$test -eq 123
-ne
Not equal / Ei võrdu (sarnane <> või !=)
$test = 100
$test -ne 123
-gt
Suurem kui / Suurem (vastab >)
$test = 100
$test -gt 123
-ge
Suurem või võrdne / Suurem või võrdselt (vastab >=)
$test = 100
$test -ge 123
-lt
Vähem kui / Vähem (vastab <)
$test = 100
$test -lt 123
-le
Vähem kui või võrdne / Vähem või võrdselt (vastab <=)
$test = 100
$test -le 123
On ka teisi sarnaseid operaatorite, mis võimaldavad näiteks võrrelda stringe, arvestades asendussümbolit, või kasutada regulaaravaldisi vastete leidmiseks. Nendest räägime detailsemalt järgmistes artiklites. Sümboleid ja = ei kasutata võrdlemiseks, kuna need on määratud muudele eesmärkidele.
Määrangu operaatorid
Lisaks kõige tavalisemale operaatorile = on olemas ka teised määramisoperaatorid: +=, -=, *=, /= ja %= . Need muudavad väärtust enne määramist. Samuti käituvad ühemärgilised operaatorid ++ ja —, mis suurendavad või vähendavad muutuja väärtust — need kuuluvad samuti määramisoperaatorite hulka.
Loogilised operaatorid
Komplekssete tingimuste kirjeldamiseks on ainult võrreldamine ebapiisav. Iga loogilisi väljendeid saab kirjutada operaatorite abil: -and, -or, -xor, -not ja !.. Need toimivad nagu teistes programmeerimiskeeltes, samas saab kasutada ka ümmarguseid sulgusid, et määrata arvutamise järjekorda:
("Test" -eq "Test") -and (100 -eq 100)
-not (123 -gt 321)
!(123 -gt 321)
Tingimuslikud üleminekud
PowerShellis on tühjendusoperatsioonid: IF(IF…ELSE, IF…ELSEIF…ELSE) ja SWITCH. Vaatame neid näiteid:
[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 või väärtus ei ole määratletud"}
}
Silmused
PowerShellis on mitu tüüpi tsükleid: WHILE, DO WHILE, DO UNTIL, FOR ja FOREACH.
Eeltingimusega tsükkel töötab, kui/samas kui see kehtib:
[int]$test = 0
while ($test -lt 10) {
Write-Host $test
$test = $test + 1
}
Järeltingimusega tsüklid töötavad vähemalt korra, kuna tingimuse kontroll tehakse pärast iteratsiooni. Sellega seoses DO WHILE töötab seni, kuni tingimus on tõsi, ja DO UNTIL seni, kuni see on vale:
[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)
FOR-tsükli iteratsioonide arv on eelnevalt teada:
for ([int]$test = 0; $test -lt 10; $test++) {
Write-Host $test
}
FOREACH tsüklis toimub massiivi või kollektsiooni (häshtabelite) elementide läbikäimine:
$test_collection = "item1", "item2", "item3"
foreach ($item in $test_collection)
{
Write-Host $item
}
Massiivid
PowerShelli muutujaid kasutatakse mitte ainult üksikute objektide (number, string jne) hoidmiseks, vaid ka mitme objekti jaoks. Lihtsaim selliste muutujate vorm on massiivid. Massiiv võib koosneda mitmest elemendist, ühest elemendist või olla tühi, st mitte sisaldada elemente. Selle deklareerimiseks kasutatakse operaatorit @(), mis tuleb meelde jätta järgmises artiklis — see on väga oluline, et lisada massiivi teisi massiive (luua mitmemõõtmelisi massiive), edastada massiive funktsioonidesse argumendina ja sarnaste ülesannete täitmiseks:
$test_array = @() #loome tühi massiivMassiivi initsialiseerimisel loetletakse selle väärtused koma kaudu (eriline operaator, ,):
$test_array = @(1, 2, 3, 4) # loome massiivi neljast elemendist Enamikul juhtudel saab operaatori @() vahele jätta:
$test_array = 1, 2, 3, 4Sellisel juhul initsialiseeritakse ühe elemendi massiiv järgmiselt:
$test_array = , 1Massiivielementide juurde pääsemiseks kasutatakse nullist algavat täisarvulist indeksi ja indeksimärki (ruudud):
$test_array[0] = 1Mitmeid indekseid saab määrata koma abil, sealhulgas korduvaid:
$test_array = "üks", "kaks", "kolm", "neli"
$test_array[0,1,2,3]
$test_array[1,1,3,3,0] 
Operaator .. (kaks punkti — vahemiku operaator) tagastab täisarvude massiivi, mis asub teatud ülemise ja alumise piiri vahel. Näiteks väljend 1..4 tagastab massiivi neljast elemendist @(1, 2, 3, 4) ja väljend 8..5 — massiivi @(8, 7, 6, 5).
Vahemiku operaatori abil saab initsialiseerida massiivi ($test_array = 1..4) või saada lõike (slice), st elementide järjestus ühest massiivist, mille indeksid on teisest. Samas tähistab negatiivne number -1 massiivi viimast elementi, -2 — eelviimast jne.
$test_array = "üks", "kaks", "kolm", "neli"
$test_array[0..2]
$test_array[2..0]
$test_array[-1..0]
$test_array[-2..1]Pange tähele, et täisarvulise massiivi väärtused võivad olla suuremad kui massiivi andmete maksimaalne indeks. Sel juhul tagastatakse kõik väärtused kuni viimase:
$test_array[0..100]Kui proovida pöörduda ainsa mittetagasitatava massiivi elemendi poole, tagastatakse väärtus $null.
PowerShellis võivad massiivid sisaldada erinevat tüüpi elemente või olla rangelt tüübitud:
$test_array = 1, 2, "test", 3, 4
for ([int]$i = 0; $i -lt $test_array.count; $i++)
{
Write-Host $test_array[$i]
}
Kus omadus $test_array.count tähistab massiivi elementide arvu.
Näide rangelt tüübitud massiivi loomisest:
[int[]]$test_array = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
Hash-tabelid
Teine põhivariable tüüp PowerShelli keeles on hash-tabelid, mida tuntakse ka assotsiatiivsete massiividena. Hashtable'id sarnanevad JSON objektiga ja ehitatakse võtme-väärtuse printsiibil. Erinevalt tavalisest massiivist pääseb nendelementidele juurde nimetatud võtmete kaudu, mis on objekti omadused (samuti võib kasutada indeksite operaatorit — ruudukaarte).
Tühja hash-tabeli saab deklareerida teenuse sümboli @ ja operaatorite sulgudega:
$test_hashtable = @{}Deklareerimise ajal on võimalik kohe luua võtmed ja määrata neile väärtused:
$test_hashtable = @{one="üks"; two="kaks"; three="kolm"; "some key"="some value"}Element lisamiseks hajutustabelisse tuleb sellele määrata veel mitteolev võti või kasutada meetodit Add(). Kui määramine toimub olemasoleva võtmega, muudetakse selle väärtust. Elementide eemaldamiseks hajutustabelist kasutatakse meetodit Remove().
$test_hashtable."some key"
$test_hashtable["some key"]
$test_hashtable.Add("four", "neli")
$test_hashtable.five = "viis"
$test_hashtable['five'] = "muudame väärtust"
$test_hashtable.Remove("one") 
Seda tüüpi muutujaid saab edastada argumentidena funktsioonidele ja cmdletidele — järgmises artiklis uurime, kuidas seda teha, samuti vaatame veel ühte sarnast tüüpi — PSCustomObject.
Funktsioonid
PowerShelli keeles on kõik vajalikud elemendid protseduuriliseks programmeerimiseks, sealhulgas funktsioonid. Nende kirjeldamiseks kasutatakse märksõna Function, millele järgneb funktsiooni nimi ja sulgudes funktsiooni keha. Kui on vajalik funktsioonile argumente edastada, saab need märkida kohe pärast nime ümmargustes sulgudes.
function funktsiooni-nimi (argument1, ..., argumentN)
{
funktsiooni-keha
}
Funktsioon tagastab alati tulemuse — see on tulemuste massiiv kõigist selle avaldustest, kui neid on rohkem kui üks. Kui avaldus on üks, tagastatakse vastava tüübi ainulaadne väärtus. Konstruktsioon return $value lisab elemendi väärtusega $value tulemuste massiivi ja katkestab lausete nimekirja täitmise, samas kui tühi funktsioon tagastab $null.
Loome näiteks funktsiooni, mis tõstab arvu ruutu:
function sqr ($number)
{
return $number * $number
}
Oluline on märkida, et funktsiooni kehas saab kasutada kõiki muutujaid, mis on deklareeritud enne selle kutsumist, ja PowerShellis funktsioonide kutsumine võib tunduda harjumatu: argumendid (kui neid on) ei ole ümmargustes sulgudes ja neid eraldatakse tühikutega.
sqr 2või selline:
sqr -number 2Argumentide edastamise viisi tõttu tuleb mõnikord funktsioon ise panna sulgudesse:
function test_func ($n) {}
test_func -eq $null # funktsiooni ei ole kutsutud
(test_func) -eq $null # väljundi tulemus — $true 
Funktsiooni kirjeldamisel saab argumentidele määrata vaikeväärtused:
function func ($arg = value) {
#funktsiooni keha
}
On olemas ka teine süntaks funktsiooni argumentide kirjeldamiseks, lisaks võivad parameetrid lugeda voost – kõik see tuleb kasuks järgmises artiklis, kus uurime eksporditud mooduleid ja oma käsureakäskluste loomist.
Vigade käsitsemine
PowerShellis on olemas mehhanism Try…Catch…Finally, mis võimaldab erandeid töödelda. Try plokki pannakse kood, kus võib esineda viga, ja Catch plokki – selle töötleja. Kui viga ei esine, ei täidetud Catch plokk. Finally plokk täidetakse pärast Try plokki, sõltumata vigade esinemisest, ja Catch plokke võib olla mitu erinevat tüüpi erandite jaoks. Isegi erand talletatakse deklaratsioonita vaikimisi muutuja ($_) ja seda on lihtne välja tuua. Allolevas näites rakendame kaitset vale väärtuse sisestamise eest:
try {
[int]$test = Read-Host "Sisestage number"
100 / $test
} catch {
Write-Warning "Vale number"
Write-Host $_
}
Selle ülevaatega PowerShelli programmeerimise põhitõdedest lõpetame. Järgmistes artiklites uurime põhjalikumalt erinevat tüüpi muutujate, kollektsioonide, regulaaravalduste, funktsioonide, moodulite ja enda cmdlet'ide loomist, samuti objektorienteeritud programmeerimist.
Allikas: habr.com
