Kio estas Windows PowerShell kaj per kio ĝi estas manĝata? Parto 2: Enkonduko al la programlingvo

Historie, komandliniaj utilecoj en Unikso-sistemoj estas pli bone evoluintaj ol en Vindozo, sed kun la apero de nova solvo, la situacio ŝanĝiĝis.

PowerShell povas esti skribita en interpretita, multi-paradigma lingvo kiu havas elementojn de klasika procedura, objekt-orientita, kaj eĉ funkcia programado: kondiĉa disbranĉigo, bukloj, variabloj, tabeloj, hashtabeloj, klasoj, erartraktado, same kiel funkcioj, cmdlets, kaj duktoj. Antaŭa artikolo estis dediĉita al la bazaĵoj de laboro en la medio, kaj nun ni ofertas al niaj legantoj malgrandan konsultlibron por programistoj.

Enhavtabelo:

komentoj
Variabloj kaj iliaj tipoj
Sistemaj variabloj
Ampleksoj
Mediaj variabloj (medio)
Aritmetikaj kaj komparaj operatoroj
Operaciantoj de tasko
Logikaj operatoroj
Kondiĉa Salto
Cikloj
Aroj
Hash-tabeloj
Funkcioj
Eraro prilaborado

Vi povas skribi kodon en iu ajn tekstredaktilo aŭ uzante integran evoluan medion - la plej facila maniero estas preni la Windows PowerShell ISE kiu venas kun Microsoft-servila operaciumo. Ĉi tio estas nur necesa por sufiĉe kompleksaj skriptoj: mallongaj aroj de komandoj estas pli facile ekzekuteblaj interage.

komentoj

Uzi komentojn estas konsiderata parto de bona programa stilo kune kun bonorda indentaĵo kaj blankspaco:

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

<# 

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

#>

Variabloj kaj iliaj tipoj

Variabloj en PowerShell estas nomitaj objektoj. Iliaj nomoj povas inkluzivi la substrekon, same kiel literojn kaj ciferojn. La $ simbolo estas ĉiam uzata antaŭ la nomo, kaj por deklari variablon, sufiĉas doni al la interpretisto validan nomon:

Por pravalorigi variablon (asigni valoron al ĝi), la asigno operatoro (simbolo =) estas uzata:

$test = 100

Vi povas deklari variablon specifante ĝian tipon inter kvadrataj krampoj (tipa rolanta operatoro) antaŭ la nomo aŭ valoro:

[int]$test = 100

$test = [int]100

Gravas kompreni, ke variabloj en PowerShell estas plenrajtaj objektoj (klasoj) kun propraĵoj kaj metodoj, kies tipoj baziĝas sur tiuj en .NET Core. Ni listigas la ĉefajn:

Tipo (.NET-klaso)

Priskribo

Ekzemplo de kodo

[ŝnuro] Sistemo.String

Unikoda ĉeno 

$testo = "testo"
$testo = 'testo'

[char]Sistemo.Char

Unikoda signo (16 bitoj)

[char]$testo = 'c'

[bool] Sistemo.Boolean

bulea tipo (bulea Vera aŭ Falsa)

[bool]$testo = $vera

[int] Sistemo.Int32

tridek du bitoj entjero (32 bitoj)

[int]$testo = 123456789

[longa] System.Int64

sesdek kvar bitoj entjero (64 bitoj)

[longa]$testo = 12345678910

[single] Sistemo.Single

glitkoma nombro 32 bitoj longa

[ununura]$testo = 12345.6789

[duobla]Sistemo.Duoble

glitkoma nombro da longo 64 bitoj (8 bajtoj)

[duobla]$testo = 123456789.101112

[decimal] Sistemo.Decimal

128-bita glitkoma nombro (postulata por finiĝi per d)

[decimala]$testo = 12345.6789d

[DateTime]System.DateTime

dato kaj horo 

$testo = Akiri Daton

[tabelo] Sistemo.Objekto[]

tabelo kies elementindekso komenciĝas je 0

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

[hashtable] Sistemo.Kolektoj.Hashtable

hashtabeloj estas asociaj tabeloj kun nomitaj ŝlosiloj, konstruitaj laŭ la principo: @{key = "valoro"}

$test_hashtable = @{one="unu"; du="du"; tri="tri"}

PowerShell subtenas implican tipkonvertiĝon, krome, la tipo de variablo povas esti ŝanĝita sur la flugo (ekzemple, uzante tasko operatoro), se ĝi ne estas specifita perforte - en ĉi tiu kazo, la interpretisto donos eraron. Vi povas determini la tipon de la variablo de la antaŭa ekzemplo vokante la metodon GetType():

$test.GetType().FullName

Estas kelkaj cmdletoj por manipuli variablojn. Ilia listo en oportuna formo estas montrata per la komando:

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

Por vidi deklaritajn variablojn kaj iliajn valorojn, vi povas uzi specialan cmdlet:

Get-Variable | more

Ĉi tiu metodo ŝajnas tro maloportuna, estas multe pli oportune labori kun variabloj per operatoroj aŭ rekte alirante iliajn trajtojn kaj metodojn. Tamen, cmdletoj havas rajton ekzisti ĉar ili permesas al vi agordi kelkajn pliajn parametrojn. Gravas kompreni, ke uzantaj variabloj estas nur difinitaj ene de la nuna sesio. Kiam la konzolo estas fermita aŭ la skripto finiĝas, ili estas forigitaj.

Sistemaj variabloj

Aldone al tiuj deklaritaj de la uzanto, ekzistas enkonstruitaj (sistemaj) variabloj kiuj ne estas forigitaj post kiam la nuna sesio finiĝas. Ili estas dividitaj en du tipojn, dum PowerShell-ŝtataj datumoj estas stokitaj en aŭtomataj variabloj, al kiuj oni ne povas asigni arbitrajn valorojn. Ĉi tiuj inkluzivas, ekzemple, $PWD:

$PWD.Path

Prefervariabloj necesas por stoki uzantpreferojn, kies valoroj povas esti ŝanĝitaj. Ekzemple, uzante $ErrorActionPreference , la reago de la komanda interpretisto al la okazo de nefataj eraroj estas fiksita.

Krom operatoroj kaj cmdletoj por aliri deklaritajn variablojn, ekzistas Variablo: pseŭdo-akumulilo. Vi povas labori kun ĝi analoge kun aliaj diskoj, kaj la variabloj ĉi-kaze similas al dosiersistemaj objektoj:

Get-ChildItem Variable: | more

aŭ

ls Variable: | more

Ampleksoj

Por variabloj en PowerShell, ekzistas la koncepto de amplekso (Scope). La ago de la tutmonda amplekso (Tutmonda) validas por la tuta nuna sesio - ĝi inkluzivas, ekzemple, sistemajn variablojn. Lokaj (Lokaj) variabloj disponeblas nur en la medio kie ili estis difinitaj: diru ene de funkcio. Ekzistas ankaŭ la koncepto de la amplekso de la skripto (Skripto), sed por skriptokomandoj, ĝi estas esence loka. Defaŭlte, dum deklarado de variabloj, ili ricevas lokan amplekson, kaj por ŝanĝi tion, vi bezonas specialan konstruaĵon kiel: $Global: variablo = valoro.

Ekzemple, tiel:

$Global:test = 100

Mediaj variabloj (medio)

Alia pseŭdo-veturado, Env:, estas havebla de PowerShell kaj povas esti uzata por aliri mediovariablojn. Kiam la ŝelo komenciĝas, ili estas kopiitaj de la gepatra procezo (tio estas, de la programo, kiu iniciatis la nunan sesion) kaj kutime iliaj komencaj valoroj estas la samaj kiel la valoroj en la kontrolpanelo. Por vidi mediajn variablojn, uzu la cmdlet Get-ChildItem aŭ ĝiajn kaŝnomojn (kaŝnomo): ls kaj dir.

dir Env:

Ĉi tiuj variabloj estas sekvencoj de bajtoj (aŭ signoj, se vi volas), kies interpreto dependas nur de la programo uzanta ilin. La cmdlets *-Variable ne funkcias kun mediaj variabloj. Por aliri ilin, vi devas uzi la veturprefikson:

$env:TEST = "Hello, World!"

Aritmetikaj kaj komparaj operatoroj

PowerShell disponigas la sekvajn aritmetikajn operatorojn: + (aldono), - (subtraho), * (obligo), / (divido), kaj % (modulo aŭ modulo). La rezulto de aritmetika esprimo estas taksita de maldekstre dekstren laŭ la ĝenerale akceptita ordo de operacioj, kaj krampoj estas uzataj por grupigi partojn de la esprimo. Spacoj inter operatoroj estas ignorataj, ili estas uzataj nur por faciligi la legadon. La + operatoro ankaŭ kunligas, kaj la * operatoro ripetas ĉenojn. Se vi provas aldoni nombron al ĉeno, ĝi estos konvertita al ĉeno. Krome, la lingvo PowerShell havas multajn komparoperantojn, kiuj kontrolas kongruon inter du valoroj kaj redonas la bulean True aŭ False:

Telefonisto

Priskribo

Ekzemplo de kodo

-ekv

Egala/Egala (simila al = aŭ == en aliaj lingvoj)

$testo = 100
$testo -eq 123 

- estas

Ne egala / Ne egala (simila al <> aŭ !=)

$testo = 100
$testo -ne 123   

-gt

Pli granda ol / Pli (analoga>)

$testo = 100
$testo -gt 123

-ge

Pli granda ol aŭ egala / Pli granda ol aŭ egala (simila al >=)

$testo = 100
$testo -ge 123

-lt

Malpli ol / Malpli (simila al <)

$testo = 100
$testo -lt 123  

-la

Malpli ol aŭ egala / Malpli ol aŭ egala (simila al <=)

$testo = 100
$testo -le 123

Estas aliaj similaj operatoroj, kiuj permesas al vi, ekzemple, kompari ŝnurojn bazitajn sur ĵokero aŭ uzi regulajn esprimojn por kongrui kun ŝablono. Ni kovros ilin detale en estontaj artikoloj. La simboloj <, > kaj = ne estas uzataj por komparo ĉar ili estas uzataj por aliaj celoj.

Operaciantoj de tasko

Krom la plej ofta = operatoro, ekzistas aliaj asigno operatoroj: +=, -=, *=, /= kaj %=. Ili ŝanĝas la valoron antaŭ asigno. La unaraj operatoroj ++ kaj -, kiuj pliigas aŭ malpliigas la valoron de variablo, kondutas simile - ili ankaŭ validas por asigno operatoroj.

Logikaj operatoroj

Komparo sole ne sufiĉas por priskribi kompleksajn kondiĉojn. Vi povas skribi ajnajn logikajn esprimojn uzante la operatorojn: -and, -or, -xor, -not kaj! .. Ili funkcias kiel en aliaj programlingvoj, dum vi povas uzi krampojn por specifi la ordon de taksado:

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

-not (123 -gt 321) 

!(123 -gt 321)

Kondiĉa Salto

Branĉaj funkciigistoj en PowerShell estas normaj: IF(IF...ELSE, IF...ELSEIF...ELSE) kaj SWITCH. Ni rigardu ilian uzon kun ekzemploj:

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

Cikloj

PowerShell havas plurajn variojn de bukloj: WHILE, DO WHILE, DO UNTIL, FOR kaj FOREACH.

Buklo kun antaŭkondiĉo funkcias se/kondiĉe ke ĝi estas vera:

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

Bukloj kun postkondiĉo ruliĝos almenaŭ unufoje, ĉar la kondiĉo estas kontrolita post la ripeto. Samtempe, DO WHILE funkcias dum la kondiĉo estas vera, kaj DO UNTIL funkcias dum ĝi estas malvera:

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

La nombro da ripetoj de la FOR-buklo estas konata anticipe:

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

En la buklo FOREACH, ripetas super la elementoj de tabelo aŭ kolekto (hashtabelo):

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

Aroj

PowerShell-variabloj stokas ne nur unuopajn objektojn (nombro, ŝnuro, ktp.), sed ankaŭ plurajn objektojn. La plej simpla speco de tiaj variabloj estas tabeloj. Tabelo povas konsisti el pluraj elementoj, unu elemento, aŭ esti malplena, t.e. enhavas neniujn elementojn. Ĝi estas deklarita uzante la operatoron @(), kiun ni bezonos en la sekva artikolo - ĝi estas tre grava por aldoni aliajn tabelojn al tabelo (krei plurdimensiajn tabelojn), pasi tabelojn al funkcioj kiel argumento, kaj similaj taskoj:

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

Kiam tabelo estas pravigita, ĝiaj valoroj estas listigitaj apartigitaj per komoj (speciala operatoro ,):

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

Plejofte, la operatoro @() povas esti preterlasita:

$test_array = 1, 2, 3, 4

En ĉi tiu kazo, tabelo de unu elemento estas pravigita jene

$test_array = , 1

Tabelelementoj estas aliritaj uzante nul-bazitan entjerindekson kaj la indeksfunkciigiston (kvadrataj krampoj):

$test_array[0] = 1

Vi povas specifi plurajn indeksojn apartigitajn per komoj, inkl. ripetiĝanta:

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

Telefonisto .. (du punktoj - intervalfunkciigisto) resendas tabelon de entjeroj ene de la specifitaj supraj kaj malsupraj limoj. Ekzemple, esprimo 1..4 eligas tabelon de kvar elementoj @(1, 2, 3, 4), kaj esprimo 8..5 eligas tabelon @(8, 7, 6, 5).

Uzante la intervalfunkciigiston, vi povas pravalorigi tabelon ($test_array = 1..4) aŭ akiri tranĉaĵon (tranĉaĵo), t.e. sekvenco de elementoj de unu tabelo kun indeksoj de alia. En ĉi tiu kazo, negativa nombro -1 indikas la lastan elementon de la tabelo, -2 - la antaŭlasta, ktp.

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

Notu, ke entjeraj tabelaj valoroj povas esti pli grandaj ol la maksimuma indeksa valoro de la datuma tabelo. En ĉi tiu kazo, ĉiuj valoroj estas resenditaj ĝis la lasta:

$test_array[0..100]

Se vi provas aliri ununuran neekzistantan tabelelementon, $null estas resendita.

En PowerShell, tabeloj povas enhavi elementojn de malsamaj tipoj aŭ esti forte tajpitaj:

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

Kie la posedaĵo $test_array.count estas la nombro da tabelelementoj.

Ekzemplo de kreado de forte tajpita tabelo:

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

Hash-tabeloj

Alia baza speco de variabloj en la lingvo PowerShell estas hashtabloj, ankaŭ konataj kiel asociaj tabeloj. Hashtables estas similaj al JSON-objektoj kaj estas konstruitaj laŭ ŝlosilvalora bazo. Male al ordinaraj tabeloj, iliaj elementoj estas alireblaj per nomitaj klavoj, kiuj estas propraĵoj de la objekto (vi ankaŭ povas uzi la indeksan operatoron - kvadrataj krampoj).

Malplena hashtabelo estas deklarita uzante la simbolon @ kaj funkciigistkrampojn:

$test_hashtable = @{}

Kiam vi deklaras, vi povas tuj krei ŝlosilojn kaj asigni valorojn al ili:

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

Por aldoni elementon al hashtabelo, vi devas asigni ŝlosilon kiu ankoraŭ ne ekzistas al ĝi, aŭ uzi la metodon Aldoni (). Se tasko estas farita al ekzistanta ŝlosilo, ĝia valoro ŝanĝiĝos. La metodo Remove() estas uzata por forigi elementon el hashtabelo.

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

Variabloj de ĉi tiu tipo povas esti pasitaj kiel argumentoj al funkcioj kaj cmdletoj - en la sekva artikolo ni studos kiel tio estas farita, kaj ankaŭ konsideros alian similan tipon - PSCustomObject.

Funkcioj

PowerShell havas ĉion, kion vi bezonas por procedura programado, inkluzive de funkcioj. Por priskribi ilin, la funkcio vorto Funkcio estas uzata, post kio vi devas specifi la nomon de la funkcio kaj la korpo enfermita en operatoraj krampoj. Se vi bezonas transdoni argumentojn al la funkcio, vi povas specifi ilin tuj post la nomo en krampoj.

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

La funkcio ĉiam resendas rezulton - ĝi estas tabelo de la rezultoj de ĉiuj ĝiaj deklaroj, se estas pli ol unu. Se estas nur unu deklaro, la nura valoro de la responda tipo estas resendita. La revena $valora konstruo aldonas elementon kun la valoro $valoro al la rezulta tabelo kaj ĉesigas la ekzekuton de la deklaro-listo, kaj la malplena funkcio redonas $nulo.

Ekzemple, ni kreu funkcion por kvadratigi nombron:

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

Notu, ke en la korpo de funkcio, vi povas uzi iujn ajn variablojn deklaritajn antaŭ ol voki ĝin, kaj voki funkciojn en PowerShell povas ŝajni nekutima: la argumentoj (se ekzistas) ne estas enfermitaj en krampoj kaj estas apartigitaj per spacoj.

sqr 2

aŭ tiel:

sqr -number 2

Pro la maniero kiel argumentoj estas pasigitaj, la funkcio mem foje devas esti enfermita en krampoj:

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

Kiam vi priskribas funkcion, vi povas asigni defaŭltajn valorojn al argumentoj:

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

Ekzistas alia sintakso por priskribi funkcio-argumentojn, krome, parametroj legeblas el la dukto - ĉio ĉi utilos en la sekva artikolo, kiam ni rigardos eksportitajn modulojn kaj kreante niajn proprajn cmdletojn.

Eraro prilaborado

PowerShell havas Try...Catch...Fine mekanismo por trakti esceptojn. La Try-bloko enhavas la kodon en kiu eraro povas okazi, kaj la Catch-bloko enhavas sian prizorganton. Se ne estis eraro, ĝi ne estas ekzekutita. La Finfine-bloko estas ekzekutita post la Try-bloko, sendepende de la okazo de eraro, kaj povas ekzisti pluraj Catch-blokoj por malsamaj specoj de esceptoj. La escepto mem estas skribita al nedeklarita defaŭlta variablo ($_) kaj povas esti prenita facile. En la malsupra ekzemplo, ni efektivigas protekton kontraŭ enigo de nevalida valoro:

try {

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

} catch {

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

}

Ĉi tio finas la revizion de la bazaĵoj de programado en la lingvo PowerShell. En la sekvaj artikoloj, ni studos pli detale labori kun variabloj de malsamaj tipoj, kolektoj, regulaj esprimoj, kreante funkciojn, modulojn kaj kutimajn cmdletojn, same kiel objekt-orientitan programadon.

fonto: www.habr.com