Ajalooliselt on käsuviipade tööriistad Unix-süsteemides paremad kui Windowsis, kuid uue lahenduse tulekuga on olukord muutunud.
PowerShellis on võimalik kirjutada skripte tõlgendatavas mitme paradigma keeles, mis sisaldab elemente klassikalisest protseduurilisest, objektorienteeritud ja isegi funktsionaalsest programmeerimisest: tingimuslikud üleminekud, tsüklid, muutujad, massiivid, hash-tabelid, klassid, veakäsitlus, samuti funktsioonid, cmdletid ja torud. oli pühendatud keskkonnaga töötamise põhialustele, ja nüüd pakume lugejatele väikest käsiraamatut programmeerijatele.
Sisukord:
Koodi saab kirjutada igas tekstiredaktorite või integreeritud arenduskeskkonna kasutamisega — kõige lihtsam on võtta Windows PowerShell ISE Microsofti serverite operatsioonisüsteemide komplektist. Seda vajatakse ainult piisavalt keerukate skriptide jaoks: lühikesi käsukogumeid on lihtsam täita interaktiivses režiimis.
Kommentaarid
Kommentaaride kasutamine on osa heast programmeerimisstiilist koos õige sisestamise ja vahedega:
# Для строчных комментариев используется символ решетки — содержимое строки интерпретатор не обрабатывает.
<#
Так обозначаются начало и конец блочного комментария.
Заключенный между ними текст интерпретатор игнорирует.
#>
Muutujad ja nende tüübid
Muutujad PowerShellis on nimelised objektid. Nende nimed võivad sisaldada alakriipsu, samuti tähti ja numbreid. Enne nime kasutatakse alati sümbolit $, ja muuturi deklarimiseks piisab tõlgendajale sobiva nime näitamisest:
Muutuja initsialiseerimise (väärtuse määramise) jaoks kasutatakse määramisoperaatorit (sümbol =):
$test = 100Muutuja võib deklareerida, märkides selle tüübi nurksulgudes (tüüpide konverteerimise operaator) enne nime või väärtust:
[int]$test = 100
$test = [int]100Oluline on mõista, et PowerShelli muutujad on täieõiguslikud objektid (klassid), millel on omadused ja meetodid, mille tüübid põhinevad .NET Core'is. Loetleme peamised:
Tüüp (klass .NET)
Kirjeldus
Koodinäide
[string]
System.String
Unicode string
$test = «test»
$test = ‘test’
[char]
System.Char
Unicode märk (16 bitti)
[char]$test = ‘c’
[bool]
System.Boolean
bool tüüp (loogiline väärtus True või False)
[bool]$test = $true
[int]
System.Int32
kolmekümne kahebitine täisarv (32 bitti)
[int]$test = 123456789
[long]
System.Int64
kuuskümmend neljarealine täisarv (64 bitti)
[long]$test = 12345678910
[single]
System.Single
ujuvkomaga number, pikkus 32 bitti
[single]$test = 12345.6789
[double]
System.Double
ujuvkomaga number, pikkus 64 bitti (8 baiti)
[double]$test = 123456789.101112
[decimal]
System.Decimal
ujuvkomaga number, pikkus 128 bitti (d peab olema lõpuks)
[decimal]$test = 12345.6789d
[DateTime]
System.DateTime
kuupäev ja kellaaeg
$test = Get-Date
[array]
System.Object[]
massiiv, mille elementide indeks algab 0-st
$test_array = 1, 2, "test", 3, 4
[hashtable]
System.Collections.Hashtable
hashitabelid — assotsiatiivsed massiivid nimega võtmetega, ehitatud põhimõtte järgi: @{key = "value"}
$test_hashtable = @{one="üks"; two="kaks"; three="kolm"}
PowerShell toetab vaikimisi tüüpide konversiooni, lisaks võib muutujate tüüp jooksvalt muutuda (näiteks kasutades määramisoperaatorit), kui see ei ole sunniviisiliselt määratud — sel juhul annab tõlgendaja vea. Muutujate tüüpi eelpooltoodud näites saab määrata meetodi GetType() abil:
$test.GetType().FullName 
Muutujate haldamiseks on olemas teatud hulk cmdlete. Nende nimekiri kuvatakse mugavas vormis käsku kasutades:
Get-Command -Noun Variable | ft -Property Name, Definition -AutoSize -Wrap 
Konkreetselt kuulutatud muutujaid ja nende väärtusi saab vaadata spetsiaalsete cmdlete'idega:
Get-Variable | moreSee lähenemine tundub liiga mahukas, muutujaid on palju mugavam hallata operaatorite kaudu või nende omadusi ja meetodeid otse kasutades. Sellegipoolest on cmdletidel oma koht, kuna need võimaldavad määrata mõningaid täiendavaid parameetreid. Oluline on mõista, et kasutaja määratud muutujad on määratletud ainult jooksva sessiooni raames. Pärast konsooli sulgemist või skripti lõpetamist need kustutatakse.
Süsteemimuutujad
Lisaks kasutaja poolt deklaratsiooniga olemasolevatele on olemas ka sisseehitatud (süsteemi) muutujad, mis ei kustutata jooksva sessiooni lõppedes. Need jagunevad kahte tüüpi, samal ajal kui PowerShelli olekuandmed loositakse automaatsetesse muutujatesse, millele ei saa ise meelevaldselt väärtusi määrata. Nende hulka kuulub näiteks $PWD:
$PWD.Path 
Kasutaja seadistuste salvestamiseks on vajalikud preferentsimuutujad, mille väärtusi saab muuta. Näiteks määrab $ErrorActionPreference tõlgendi käitumise kriitiliste vigade tekkimise korral.
Lisaks operaatoritele ja käskudele, millega pääseb ligi deklareeritud muutujatele, on olemas pseudokogum Variable:. Teda saab kasutada samamoodi nagu teisi kogumeid ning selles kontekstis meenutavad muutujad failisüsteemi objekte:
Get-ChildItem Variable: | morevõi
ls Variable: | more 
Muutujate ulatused
PowerShellis on muutujaid määratlevad ulatused (Scope). Globaalne ulatus (Global) kehtib kogu praeguse sessiooni jooksul — sinna kuuluvad näiteks süsteemimuutujad. Kohalikud (Local) muutujad on saadaval ainult ulatuses, kus neid on määratletud: näiteks funktsiooni sees. On olemas ka skripti ulatus (Script), kuid skripti käskude puhul on see tegelikult kohalik. Muutujate deklareerimisel määratakse neile vaikimisi kohalik ulatus ja selle muutmiseks on vajalik eriline konstruktsioon kujul: $Global: muutuja = väärtus.
Näiteks nii:
$Global:test = 100
Keskkonna (keskkonna) muutujad
PowerShelli kaudu on veel üks pseudokogum Env:, mille abil saab pääseda keskkonnamuutujatele. Shelli käivitamisel kopeeritakse need vanemprotsessist (st käivitanud programmi praegusest sessioonist) ja tavaliselt on nende esialgsed väärtused samad, mis juhtpaneelil. Keskkonnamuutujate vaatamiseks saab kasutada käskude Get-ChildItem või selle aliaseid: ls ja dir.
dir Env: 
Need muutujad esitavad bites (või karaktereid, kui soovite), mille tõlgendus sõltub vaid neid kasutavast programmist. Muutujate keskkonnamuutujad ei tööta koos käskudega *-Variable. Neile pääsemiseks tuleb kasutada ketta eeltee:
$env:TEST = "Tere, maailm!" 
Aritmeetilised operaatorid ja võrdlusoperaatorid
PowerShell sisaldab järgmisi arvutusteke: + (liitmine), – (lahutamine), * (korrutamine), / (jagamine) ja % (moodul või jagamisjääk). Arvutuse tulemused arvutatakse vasakult paremale üldiselt kehtiva tehete järjekorra järgi, ning tehete rühmamiseks kasutatakse ümarate sulgude. Tühikud tehete vahel ignoreeritakse, neid kasutatakse ainult tekstilise arusaadavuse kergendamiseks. Ooper + liidab ka, ja ooper * korrutab stringe. Kui proovite numbrit stringiga liita, muudetakse see stringiks. Lisaks on PowerShellis palju võrdlusoperatore, mis kontrollivad kaks väärtust ning tagastavad loogilisi True või False:
Operaator
Kirjeldus
Koodinäide
-eq
Võrdne / R равно (sarnane = või == teistes keeltes)
$test = 100
$test -eq 123
-ne
Mitte võrdelne / Не равно (sarnane või !=)
$test = 100
$test -ne 123
-gt
Suurem kui / Больше (sarnane >)
$test = 100
$test -gt 123
-ge
Suurem või võrdelne / Больше или равно (sarnane >=)
$test = 100
$test -ge 123
-lt
Vähem kui / Меньше (sarnane <)
$test = 100
$test -lt 123
-le
Vähem või võrdelne / Меньше или равно (sarnane <=)
$test = 100
$test -le 123
On ka teisi sarnaseid ooperatore, mis võimaldavad näiteks võrrelda stringe wildcard märgete arvestamisel või kasutada regulaaravaldisi mustritega vastavuse leidmiseks. Nendest räägime põhjalikumalt järgmistes artiklites. Sümboleid ja = ei kasutata võrreldes, kuna need on seotud teiste eesmärkidega.
Määramisoperaatorid
Lisaks kõige levinumale ooperile =, on ka teisi määramise ooperatore: +=, -=, *=, /= ja %= . Need muudavad väärtust enne määramist. Samuti käituvad unaarsete ooperatorid ++ ja –, mis suurendavad või vähendavad muutuja väärtust – need kuuluvad samuti määramise ooperatore alla.
Loogilised operaatorid
Kompaktsete tingimuste kirjeldamiseks ei piisa ainult võrreldes. Igasuguseid loogilisi väljendeid saab kirja panna kasutades ooperatore: -and, -or, -xor, -not ja ! . Need töötavad nagu teistes programmeerimiskeeltes, samas saate kasutada ümarate sulgude abil arvutuste järjekorra määratlemiseks:
("Test" -eq "Test") -and (100 -eq 100)
-not (123 -gt 321)
!(123 -gt 321)
Tingimuslik üleminek
PowerShellis on haru ooperid standardsed: IF(IF…ELSE, IF…ELSEIF…ELSE) ja SWITCH. Tutvume nende kasutamisega näidete abil:
[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 või väärtus ei ole määratud"}
}
Tsüklid
PowerShelli keeles on mitmeid tsüklite tüüpe: WHILE, DO WHILE, DO UNTIL, FOR ja FOREACH.
Eeltingimusega tsükkel töötab, kui/kuni see on tõene:
[int]$test = 0
while ($test -lt 10) {
Write-Host $test
$test = $test + 1
}
Pärast tingimuse kontrollimist töötavad pärasttingimusega tsüklid vähemalt kord, kuna tingimuse kontroll toimub pärast iteratsiooni. Siinjuures töötab DO WHILE, kuni tingimus on tõene, 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 (hash-tabeli) elementide läbimine:
$test_collection = "item1", "item2", "item3"
foreach ($item in $test_collection)
{
Write-Host $item
}
Massiivid
PowerShelli muutujates võib talletada mitte ainult üksikobjekte (numbrid, stringid jne), vaid ka mitu. Kõige lihtsam selliste muutujate tüüp on massiivid. Massiiv võib koosneda mitmest elemendist, ühest elemendist või olla tühi, s.t mitte sisaldada elemente. Selle deklareerimiseks kasutatakse operaatorit @(), mis on vajalik järgmises artiklis — see on väga oluline teiste massiivide massiivi lisamiseks (mitmemõõtmeliste massiivide loomine), massiivide edastamiseks funktsioonidesse argumentidena jne:
$test_array = @() #loome tühja massiiviMassiivi initsialiseerimisel loetletakse väärtused koma kaudu (eriline operaator ,):
$test_array = @(1, 2, 3, 4) # loome massiivi neljast elemendist Enamikul juhtudel saab operaatori @() jätta vahele:
$test_array = 1, 2, 3, 4Sellisel juhul initsialiseeritakse ühe elemendiga massiiv järgmiselt
$test_array = , 1Massiivi elementidele pääseb ligi nullist algava täisarvulise indeksi ja indekseerimise operaatori (ristkülikukujulised sulud) abil:
$test_array[0] = 1Võib määrata mitu indeksit, sealhulgas korduvaid:
$test_array = "üks", "kaks", "kolm", "neli"
$test_array[0,1,2,3]
$test_array[1,1,3,3,0] 
Operaator .. (kahe punkti — vahemiku operaator) tagastab täisarvude massiivi antud ülemise ja alumise piiri vahel. Näiteks väljend 1..4 toob välja nelja elemendiga massiivi @(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õiget, st elementide järjestust ühest massiivist teise indekseerimise teel. Siinkohal 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äisarvumassiivi väärtused võivad olla suuremad kui massiivi andmete maksimaalne indeks. Sellisel juhul tagastatakse kõik väärtused kuni viimase:
$test_array[0..100]Kui proovite juurde pääseda ainsale mitteseksisteerivale massiivi elemendile, tagastatakse väärtus $null.
PowerShellis võivad massiivid sisaldada erinevat tüüpi elemente või olla rangelt tüübistatud:
$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 näitab massiivi elementide arvu.
Näide rangelt tüübistatud massiivi loomisest:
[int[]]$test_array = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
Hash-tabelid
Veel üks põhimuutuja tüüp PowerShelli keeles on hash-tabelid, mida nimetatakse ka assotsiatiivseteks massiivideks. Hashtable’id sarnanevad JSON objekti ja ehitatakse võtme-väärtuse printsiipide kohaselt. Erinevalt tavalistest massiividest pääseda nende elementidele juurde nimetatud võtmete kaudu, mis on objekti omadused (saate kasutada ka indeksoperaatorit — ruudukaarte).
Tühi hash-tabel kuulutatakse välja teenusmärgi @ ja operatiivkaarte abil:
$test_hashtable = @{}Välja kuulutamisel saate kohe luua võtmed ja määrata neile väärtused:
$test_hashtable = @{one="üks"; two="kaks"; three="kolm"; "some key"="some value"}Elemendi lisamiseks hash-tabelisse peate määrama talle veel mitteseksisteeriva võtme või kasutama Meetodit Add(). Kui määramine toimub olemasoleva võtmega, siis selle väärtus muutub. Hash-tabelist elemendi eemaldamiseks kasutatakse meetodit Remove().
$test_hashtable."some key"
$test_hashtable["some key"]
$test_hashtable.Add("four", "neli")
$test_hashtable.five = "viis"
$test_hashtable['five'] = "asendame väärtuse"
$test_hashtable.Remove("one") 
Seda tüüpi muutujaid saab edastada funktsioonide ja käsurea käskude argumentidena – järgmisel artiklil uurime, kuidas seda teha, ning arutame ka teist sarnast tüüpi – PSCustomObject.
Funktsioonid
PowerShelli keeles on olemas kõik vajalikud elemendid protseduuriliseks programmeerimiseks, sealhulgas funktsioonid. Nende määratlemiseks kasutatakse võtmesõna Function, millele järgneb funktsiooni nimi ja sulgudes keha. Kui funktsiooni on vaja edastada argumente, saab need kohe pärast nime sulgudesse kirjutada.
function funktsiooni-nimi (argument1, ..., argumentN)
{
funktsiooni-keha
}
Funktsioon tagastab alati tulemuse – see on kõikide tema käskude massiiv, kui neid on rohkem kui üks. Kui käsk on üks, tagastatakse vastava tüübi üks väärtus. Konstruktsioon return $value lisab elemendi väärtusega $value tulemuste massiivi ja katkestab statement listi täitmise, samas kui tühi funktsioon tagastab $null.
Näiteks loome funktsiooni, mis arvutab arvu ruudu:
function sqr ($number)
{
return $number * $number
}
Märgi, et funktsiooni kehas võib kasutada kõiki muutujaid, mis on kuulutatud enne selle kutsumist, ning funktsioonide kutsumine PowerShellis võib tunduda ebaharilik: argumendid (kui need on olemas) ei ole sulgudes ja neid eraldatakse tühikutega.
sqr 2või nii:
sqr -number 2Argumentide edastamise viisist tulenevalt tuleb vahel funktsioon ise sulgudesse panna:
function test_func ($n) {}
test_func -eq $null # funktsiooni ei kutsutud
(test_func) -eq $null # väljendi tulemus – $true 
Funktsiooni määratlemisel on võimalik argumentidele määrata vaikeväärtused:
function func ($arg = value) {
#funktsiooni keha
}
Lisaks on olemas veel üks sünnaks funktsiooni argumentide määratlemiseks; lisaks saavad parameetrid konveierilt lugeda – kõik see on kasulik järgmisel artiklil, kui uurime eksporditavaid mooduleid ja oma käsureakäskude loomist.
Vigade käsitlemine
PowerShellis on mehhanism Try…Catch…Finally, mis võimaldab käidelda erandeid. Try plokki pannakse kood, kus võib esineda viga, ja Catch plokki - selle töötleja. Kui viga ei esine, siis Catch plokk ei käivituda. Finally plokk käivitub alati Try ploki järel, olenemata veast, ja Catch plokke võib olla mitu erinevat tüüpi erandite jaoks. Ise erand salvestatakse automaatselt määratud muutuja ($_) ja seda saab lihtsalt välja tõmmata. Alljärgnevas näites rakendame kaitset vale sisendi eest:
try {
[int]$test = Read-Host "Sisestage arv"
100 / $test
} catch {
Write-Warning "Vale arv"
Write-Host $_
}
Siin lõpetame PowerShell programmeerimise aluste käsitlemise. Järgmistes artiklites uurime põhjalikumalt erinevat tüüpi muutujate, kollektsioonide, regulaaravaldiste, funktsioonide, moodulite ja kohandatud cmdletide loomisega, samuti objektorienteeritud programmeerimisega.
Allikas: habr.com
