Mis on Windows PowerShell ja millega seda süüakse? Osa 2: Sissejuhatus programmeerimiskeelde

Ajalooliselt on Unixi süsteemide käsurea utiliidid paremini arenenud kui Windowsis, kuid uue lahenduse tulekuga on olukord muutunud.

PowerShelli saab skriptida tõlgendatud, mitme paradigmaga keeles, millel on klassikalise protseduurilise, objektorienteeritud ja isegi funktsionaalse programmeerimise elemente: tingimuslik hargnemine, tsüklid, muutujad, massiivid, räsitabelid, klassid, veakäsitlus, aga ka funktsioonid, cmdletid ja torujuhtmed . Eelmine artikkel oli pühendatud keskkonnas töötamise põhitõdedele ja nüüd pakume lugejatele väikest juhendit programmeerijatele.

Оглавление

Kommentaarid
Muutujad ja nende tüübid
Süsteemi muutujad
Ulatused
Keskkonnamuutujad (keskkond)
Aritmeetilised ja võrdlusoperaatorid
Määramise operaatorid
Loogilised operaatorid
Tingimuslik hüpe
Tsüklid
Massiivid
Räsi tabelid
Funktsioonid
Viga töötlemisel

Koodi saab kirjutada mis tahes tekstiredaktoris või integreeritud arenduskeskkonnas – kõige lihtsam on võtta Microsofti serveri operatsioonisüsteemidega kaasas olev Windows PowerShell ISE. See on vajalik ainult üsna keerukate skriptide puhul: lühikesi käskude komplekte on lihtsam interaktiivselt täita.

Kommentaarid

Kommentaaride kasutamist peetakse hea programmeerimisstiili osaks koos korraliku taande ja tühikutega:

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

<# 

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

#>

Muutujad ja nende tüübid

PowerShelli muutujad on nimega objektid. Nende nimed võivad sisaldada allkriipsu, samuti tähti ja numbreid. Nimele eelneb alati sümbol $ ja muutuja deklareerimiseks peate lihtsalt andma tõlgile kehtiva nime:

Muutuja lähtestamiseks (sellele väärtuse määramiseks) kasutatakse määramisoperaatorit (sümbol =):

$test = 100

Muutuja saab deklareerida, määrates selle tüübi nurksulgudes (tüüpi casting operator) enne nime või väärtust:

[int]$test = 100

$test = [int]100

Oluline on mõista, et PowerShelli muutujad on täisväärtuslikud objektid (klassid), millel on omadused ja meetodid, mille tüübid põhinevad .NET Core'i omadel. Loetleme peamised:

Tüüp (.NET klass)

Kirjeldus

Koodi näide

[string] Süsteem.String

Unicode'i string 

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

[char]Süsteem.Char

Unicode'i märk (16 bitti)

[char]$test = 'c'

[bool] System. Boolean

tõeväärtus (tõene tõene või väär)

[bool]$test = $tõene

[int] System.Int32

kolmekümne kahe bitine täisarv (32 bitti)

[int]$test = 123456789

[pikk] System.Int64

kuuskümmend neli bitti täisarv (64 bitti)

[pikk]$test = 12345678910

[üksik] System.Single

ujukomaarv 32 bitti pikk

[üksik]$test = 12345.6789

[double]Süsteem.Topelt

ujukomaarv pikkusega 64 bitti (8 baiti)

[topelt]$test = 123456789.101112

[decimal]System.Decimal

128-bitine ujukomaarv (nõutav, et lõppeda tähega d)

[decimal]$ test = 12345.6789d

[DateTime]System.DateTime

päev ja aeg 

$test = GetDate

[massiiv] Süsteem.Objekt[]

massiiv, mille elementide indeks algab 0-st

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

[räsitabel] System.Collections.Hashtable

räsitabelid on nimeliste võtmetega assotsiatiivsed massiivid, mis on üles ehitatud põhimõttel: @{key = "value"}

$test_hashtable = @{one="üks"; kaks = "kaks"; kolm = kolm"}

PowerShell toetab kaudset tüübiteisendust, lisaks saab muutuja tüüpi käigu pealt muuta (näiteks määramisoperaatori abil), kui see pole sunniviisiliselt määratud - sel juhul annab tõlk vea. Muutuja tüübi saate määrata eelmisest näitest, kutsudes välja GetType() meetodi:

$test.GetType().FullName

Muutujate haldamiseks on mitu cmdlet-käsku. Nende loendit mugaval kujul kuvatakse käsuga:

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

Deklareeritud muutujate ja nende väärtuste vaatamiseks saate kasutada spetsiaalset cmdleti:

Get-Variable | more

See meetod tundub liiga tülikas, muutujatega on palju mugavam töötada operaatorite kaudu või nende omadustele ja meetoditele otse ligi pääsedes. Kuid cmdlet-käskudel on õigus eksisteerida, kuna need võimaldavad teil määrata mõningaid lisaparameetreid. Oluline on mõista, et kasutaja muutujad määratletakse ainult praeguse seansi jooksul. Kui konsool suletakse või skript lõpeb, need kustutatakse.

Süsteemi muutujad

Lisaks kasutaja deklareeritud muutujatele on sisseehitatud (süsteemi) muutujad, mida pärast praeguse seansi lõppu ei kustutata. Need on jagatud kahte tüüpi, samas kui PowerShelli olekuandmed salvestatakse automaatsetesse muutujatesse, millele ei saa iseseisvalt suvalisi väärtusi määrata. Nende hulka kuuluvad näiteks $PWD:

$PWD.Path

Eelistusmuutujad on vajalikud kasutaja eelistuste salvestamiseks, mille väärtusi saab muuta. Näiteks kasutades $ErrorActionPreference , määratakse käsutõlgi reaktsioon mittefataalsete vigade ilmnemisele.

Lisaks deklareeritud muutujatele juurdepääsu operaatoritele ja cmdlet-käskudele on olemas muutuja: pseudoakumulaator. Saate sellega töötada analoogselt teiste draividega ja muutujad meenutavad sel juhul failisüsteemi objekte:

Get-ChildItem Variable: | more

või

ls Variable: | more

Ulatused

PowerShelli muutujatel on kontseptsioon nimega ulatus. Globaalne ulatus kehtib kogu praegusele seansile – see hõlmab näiteks süsteemimuutujaid. Kohalikud muutujad on saadaval ainult selles ulatuses, kus need määratleti: näiteks funktsiooni sees. On olemas ka skripti ulatuse (Script) mõiste, kuid skriptikäskude puhul on see sisuliselt lokaalne. Vaikimisi antakse muutujate deklareerimisel neile lokaalne ulatus ja selle muutmiseks on vaja spetsiaalset konstruktsiooni nagu: $Global: muutuja = väärtus.

Näiteks nii:

$Global:test = 100

Keskkonnamuutujad (keskkond)

Teine pseudodraiv Env: on saadaval PowerShellist ja seda saab kasutada keskkonnamuutujatele juurdepääsuks. Kui kest käivitub, kopeeritakse need põhiprotsessist (st praeguse seansi algatanud programmist) ja tavaliselt on nende algväärtused samad, mis juhtpaneelil olevad väärtused. Keskkonnamuutujate vaatamiseks kasutage cmdlet-käsku Get-ChildItem või selle varjunimesid (aliaseid): ls ja dir.

dir Env:

Need muutujad on baitide (või märkide jadad, kui soovite), mille tõlgendamine sõltub ainult neid kasutavast programmist. *-Muutujate cmdlet-id koos keskkonnamuutujatega ei tööta. Nendele viitamiseks peate kasutama ketta eesliidet:

$env:TEST = "Hello, World!"

Aritmeetilised ja võrdlusoperaatorid

PowerShellil on järgmised aritmeetilised operaatorid: + (liitmine), - (lahutamine), * (korrutamine), / (jagamine) ja % (jagamise moodul või jääk). Aritmeetilise avaldise tulemust hinnatakse vasakult paremale vastavalt üldtunnustatud toimingute järjekorrale ja avaldise osade rühmitamiseks kasutatakse sulgusid. Operaatorite vahelisi tühikuid eiratakse ja neid kasutatakse ainult asjade lugemise hõlbustamiseks. Ka operaator + ühendab ja operaator * kordab stringe. Kui proovite stringile numbrit lisada, teisendatakse see stringiks. Lisaks on PowerShellil palju võrdlusoperaatoreid, mis võrdlevad kahte väärtust ja tagastavad tõese tõese või väära:

Operaator

Kirjeldus

Koodi näide

-ekv

Võrdub / võrdub (sarnane = või == teistes keeltes)

$ test = 100
$test -ekv 123 

- ei

Pole võrdne / Pole võrdne (sarnane <> või !=)

$ test = 100
$test -ne 123   

-gt

Suurem kui / Rohkem (analoog>)

$ test = 100
$test -gt 123

-vanus

Suurem või võrdne / Suurem või võrdne (sarnane >=)

$ test = 100
$test -ge 123

-lt

Vähem kui / vähem (sarnane <)

$ test = 100
$test -lt 123  

-neid

Väiksem või võrdne / Väiksem või võrdne (analoog <=)

$ test = 100
$test - le 123

On ka teisi sarnaseid operaatoreid, mis võimaldavad näiteks stringe metamärgi alusel võrrelda või kasutada mustri sobitamiseks regulaaravaldisi. Vaatleme neid üksikasjalikult järgmistes artiklites. Võrdluseks ei kasutata sümboleid <, > ja =, kuna neid kasutatakse muul eesmärgil.

Määramise operaatorid

Lisaks kõige tavalisemale = operaatorile on ka teisi määramistehtereid: +=, -=, *=, /= ja %=. Nad muudavad väärtust enne määramist. Ühesõnalised operaatorid ++ ja -, mis suurendavad või vähendavad muutuja väärtust, käituvad sarnaselt – need kehtivad ka määramistehterite kohta.

Loogilised operaatorid

Ainuüksi võrdlusest ei piisa keeruliste tingimuste kirjeldamiseks. Saate kirjutada mis tahes loogilisi avaldisi kasutades operaatoreid -ja, -või, -xor, -not and! .. Need töötavad nagu teisteski programmeerimiskeeltes, samas kui saate sulgude abil määrata hindamise järjekorra:

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

-not (123 -gt 321) 

!(123 -gt 321)

Tingimuslik hüpe

PowerShelli haruoperaatorid on standardsed: IF(IF…ELSE, IF…ELSEIF…ELSE) ja SWITCH. Vaatame nende kasutamist näidetega:

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

Tsüklid

PowerShellil on mitut tüüpi silmuseid: WHILE, DO WHILE, DO UNTIL, FOR ja FOREACH.

Eeltingimusega tsükkel töötab, kui/nii kaua kui see on tõsi:

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

Järeltingimusega tsüklid jooksevad vähemalt korra, kuna tingimust kontrollitakse pärast iteratsiooni. Sel juhul töötab DO WHILE tingimusel, et tingimus on tõene, ja DO UNTIL töötab, kui 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 ette teada:

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

Silmuses FOREACH itereerib massiivi või kogumi elemente (räsitabel):

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

Massiivid

PowerShelli muutujad ei salvesta mitte ainult üksikuid objekte (number, string jne), vaid ka mitut. Selliste muutujate lihtsaimad liigid on massiivid. Massiiv võib koosneda mitmest elemendist, ühest elemendist või olla tühi, s.t. ei sisalda elemente. See deklareeritakse operaatori @() abil, mida vajame järgmises artiklis - see on väga oluline massiivile muude massiivide lisamiseks (mitmemõõtmeliste massiivide loomiseks), argumendina funktsioonidele massiivide edastamiseks ja sarnasteks ülesanneteks:

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

Massiivi lähtestamisel loetletakse selle väärtused komadega eraldatuna (spetsiaalne operaator ,):

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

Enamikul juhtudel saab @() operaatori ära jätta:

$test_array = 1, 2, 3, 4

Sel juhul lähtestatakse ühest elemendist koosnev massiiv järgmiselt

$test_array = , 1

Massiivi elementidele pääseb juurde nullpõhise täisarvuindeksi ja indeksioperaatori (nurksulud) abil:

$test_array[0] = 1

Komadega eraldatuna saab määrata mitu indeksit, sh. korduv:

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

Operaator .. (kaks punkti – vahemiku operaator) tagastab täisarvude massiivi määratud ülemises ja alumises piirides. Näiteks avaldis 1..4 väljastab neljast elemendist koosneva massiivi @(1, 2, 3, 4) ja avaldis 8..5 massiivi @(8, 7, 6, 5).

Vahemiku operaatorit kasutades saab initsialiseerida massiivi ($test_array = 1..4) või saada viilu (slice), st. elementide jada ühest massiivist teise massiivi indeksidega. Sel juhul tähistab negatiivne arv -1 massiivi viimast elementi, -2 - eelviimast jne.

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

Pange tähele, et täisarvu massiivi väärtused võivad olla suuremad kui andmemassiivi maksimaalne indeksi väärtus. Sel juhul tagastatakse kõik väärtused kuni viimaseni:

$test_array[0..100]

Kui proovite pääseda juurde ühele olematule massiivielemendile, tagastatakse $null.

PowerShellis võivad massiivid sisaldada erinevat tüüpi elemente või olla tugevasti trükitud:

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

Kus atribuut $test_array.count on massiivi elementide arv.

Tugevalt trükitud massiivi loomise näide:

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

Räsi tabelid

Teine PowerShelli muutujate põhitüüp on räsitabelid, mida nimetatakse ka assotsiatiivseteks massiivideks. Räsitabelid sarnanevad JSON-objektidega ja on üles ehitatud võtmeväärtuse alusel. Erinevalt tavalistest massiividest pääseb nende elementidele juurde nimega võtmed, mis on objekti omadused (võid kasutada ka indeksioperaatorit – nurksulud).

Tühi räsitabel deklareeritakse sümboli @ ja operaatorsulgude abil:

$test_hashtable = @{}

Deklareerimisel saate kohe võtmeid luua ja neile väärtusi määrata:

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

Räsitabelisse elemendi lisamiseks tuleb määrata sellele võti, mida veel ei eksisteeri, või kasutada meetodit Lisa (). Kui olemasolevale võtmele määratakse määramine, muutub selle väärtus. Räsitabelist elemendi eemaldamiseks kasutage meetodit Remove().

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

Seda tüüpi muutujaid saab edastada argumentidena funktsioonidele ja cmdlet-käskudele - järgmises artiklis uurime, kuidas seda tehakse, ja vaatame ka teist sarnast tüüpi - PSCustomObject.

Funktsioonid

PowerShellis on kõik, mida vajate protseduuriliseks programmeerimiseks, sealhulgas funktsioonid. Nende kirjeldamiseks kasutatakse funktsioonisõna Function, mille järel tuleb määrata funktsiooni nimi ja operaatorsulgudes olev keha. Kui peate funktsioonile edastama argumente, saate need määrata kohe sulgudes oleva nime järel.

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

Funktsioon tagastab alati tulemuse – see on kõigi selle lausete tulemuste massiiv, kui neid on rohkem kui üks. Kui on ainult üks lause, tagastatakse ainus vastavat tüüpi väärtus. Tagastatav $väärtuse konstruktsioon lisab tulemuste massiivile elemendi väärtusega $value ja katkestab lauseloendi täitmise ning tühi funktsioon tagastab $null.

Näiteks loome arvu ruudustamiseks funktsiooni:

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

Pange tähele, et funktsiooni põhiosas saate kasutada kõiki enne selle kutsumist deklareeritud muutujaid ja funktsioonide kutsumine PowerShellis võib tunduda ebatavaline: argumendid (kui neid on) ei ole sulgudes ja on eraldatud tühikutega.

sqr 2

või nii:

sqr -number 2

Argumentide edastamise viisi tõttu tuleb funktsioon ise mõnikord sulgudesse panna:

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

Funktsiooni kirjeldamisel saate argumentidele määrata vaikeväärtused:

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

Funktsiooniargumentide kirjeldamiseks on veel üks süntaks, lisaks saab konveierist lugeda parameetreid – see kõik tuleb kasuks järgmises artiklis, kui vaatleme eksporditud mooduleid ja oma cmdlette loomist.

Viga töötlemisel

PowerShellil on erandite käsitlemiseks mehhanism Proovi...Püüa...Lõpuks. Prooviplokk sisaldab koodi, milles võib tõrge ilmneda, ja Catch plokk sisaldab selle töötlejat. Kui viga ei olnud, siis seda ei teostata. Plokk Lõpuks käivitatakse pärast Try-plokki, olenemata tõrke ilmnemisest ja erinevat tüüpi erandite jaoks võib olla mitu Catch-plokki. Erand ise kirjutatakse deklareerimata vaikemuutujasse ($_) ja seda saab hõlpsasti hankida. Allolevas näites rakendame kaitset vale väärtuse sisestamise eest:

try {

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

} catch {

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

}

Siin peaksime lõpetama PowerShelli programmeerimise põhitõdede ülevaate. Järgmistes artiklites uurime üksikasjalikumalt töötamist erinevat tüüpi muutujatega, kogude, regulaaravaldistega, funktsioonide, moodulite ja kohandatud cmdlet-ide loomist ning objektorienteeritud programmeerimist.

Allikas: www.habr.com