🥇Zer da Windows PowerShell eta zertarako erabiltzen da? 2. zatia: Programazio Lengoaiaren Sarrera

Historikoki, komando-lerroko utilitateak Unix sistemetan Windows-en baino hobeto garatu dira, baina irtenbide berri baten agerpenarekin egoera aldatu egin da.

PowerShell-ek script-ak interpretatu eta paradigma anitzeko lengoaia batean idazteko aukera ematen du, prozedura klasikoko, objektuetara zuzendutako eta baita programazio funtzionalaren elementuak dituena: baldintzapeko adar, begiztak, aldagaiak, matrizeak, hash taulak, klaseak, erroreen kudeaketa eta baita. funtzioak, cmdlet-ak eta kanalizazioak . Aurreko artikulua ingurunean lan egiteko oinarriei buruzkoa zen, eta orain gure irakurleei programatzaileentzako erreferentzia-liburu txiki bat eskaintzen diegu.

Edukien taula:

Comments
Aldagaiak eta haien motak
Sistemaren aldagaiak
Eremua
Inguruko aldagaiak
Aritmetika eta Konparazio Eragileak
Esleipen-eragileak
Operadore logikoak
Baldintzazko jauzia
Zikloak
Arrayak
Hash taulak
funtzio
Errore bat prozesatzen

Edozein testu-editoreetan edo garapen-ingurune integratu batean idatz dezakezu kodea; modurik errazena Microsoft zerbitzari sistema eragileekin datorren Windows PowerShell ISE hartzea da. Hau script nahiko konplexuetarako bakarrik behar da: komando multzo laburrak interaktiboki exekutatzeko errazagoak dira.

Comments

Iruzkinak erabiltzea programazio-estilo onaren parte da, koska eta zuriune egokiarekin batera:

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

<# 

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

#>

Aldagaiak eta haien motak

PowerShell-eko aldagaiak izeneko objektuak dira. Haien izenek azpimarra karakterea izan dezakete, baita letrak eta zenbakiak ere. Izenak $ ikurraren aurretik jartzen du beti, eta aldagai bat deklaratzeko, interpreteari baliozko izen bat eman behar diozu:

Aldagai bat hasieratzeko (balio bat esleitu), erabili esleipen-operadorea (= ikurra):

$test = 100

Aldagai bat deklara dezakezu bere mota kortxeteen artean adieraziz (mota cast operadorea) izenaren edo balioaren aurretik:

[int]$test = 100

$test = [int]100

Garrantzitsua da ulertzea PowerShell-eko aldagaiak propietate eta metodoekin osoko objektuak (klaseak) direla, eta horien motak .NET Core-n aurkitzen direnetan oinarritzen dira. Zerrenda ditzagun nagusiak:

Mota (.NET klasea)

Description

Kode Adibidea

[katea] System.String

Unicode katea

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

[char]Sistema.Char

Unicode karakterea (16 bit)

[char]$test = 'c'

[bool] Sistema.Boolearra

Mota boolearra (Balio boolearra True edo False)

[bool]$test = $true

[int]System.Int32

hogeita hamabi biteko zenbaki osoa (32 bit)

[int]$test = 123456789

[luzea] System.Int64

hirurogeita lau biteko zenbaki osoa (64 bit)

[luzea]$test = 12345678910

[bakarra]Sistema.Single

koma mugikorreko zenbakia 32 biteko luzera duena

[bakarra]$proba = 12345.6789

[bikoitza]Sistema.Bikoitza

koma mugikorreko zenbakia 64 bit luze (8 byte)

[bikoitza]$test = 123456789.101112

[dezimal] Sistema.Dezimal

128 bit luze den koma mugikorreko zenbakia (d sartu behar du amaieran)

[hamartarra]$proba = 12345.6789d

[DateTime] System.DateTime

data eta ordua

$test = Lortu-data

[matriz]Sistema.Objektua[]

elementu-indizea 0-n hasten den array bat

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

[Hashtable] Sistema.Bildumak.Hashtable

hash-taulak izendun gakoak dituzten matrize elkartuak dira, printzipioaren arabera eraikiak: @{gakoa = "balioa"}

$test_hashtable = @{one="one"; bi="bi"; hiru="hiru"}

PowerShell-ek mota inplizituaren bihurketa onartzen du, eta aldagai baten mota berehala alda daiteke (adibidez, esleipen-operadore bat erabiliz), behartu ezean, kasu horretan interpreteak errore bat botako du. Aurreko adibidetik aldagai mota zehaztu dezakezu GetType() metodora deituz:

$test.GetType().FullName

Aldagaiak kudeatzeko cmdlet ugari daude. Horien zerrenda forma eroso batean bistaratzen da komandoa erabiliz:

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

Adierazitako aldagaiak eta haien balioak ikusteko, cmdlet berezi bat erabil dezakezu:

Get-Variable | more

Metodo honek oso astuna dirudi; askoz erosoagoa da aldagaiekin lan egitea operadoreen bidez edo haien propietate eta metodoetara zuzenean sartuz. Hala ere, cmdlet-ek bere lekua dute, parametro gehigarri batzuk ezartzeko aukera ematen baitute. Garrantzitsua da ulertzea erabiltzaileen aldagaiak uneko saioan soilik definitzen direla. Kontsola itxita edo script-a amaitutakoan, ezabatzen dira.

Sistemaren aldagaiak

Erabiltzaileak deklaratutakoez gain, uneko saioa amaitu ondoren ezabatzen ez diren aldagai barne (sistema) daude. Bi motatan banatzen dira, eta PowerShell egoeraren datuak balio arbitrarioak esleitu ezin zaizkien aldagai automatikoetan gordetzen dira. Hauek dira, adibidez, $PWD:

$PWD.Path

Erabiltzaileen hobespenak gordetzeko, hobespen-aldagaiak behar dira zeinen balioak alda daitezkeen. Adibidez, $ErrorActionPreference erabiliz komando-interpretatzailearen erreakzioa ezar dezakezu akats ez-kritikoen aurrean.

Adierazitako aldagaiak atzitzeko operadoreez eta cmdletez gain, aldagaia dago: sasi-metagailua. Beste disko batzuekin analogiaz lan egin dezakezu, eta kasu honetan aldagaiek fitxategi-sistemako objektuen antza dute:

Get-ChildItem Variable: | more

edo

ls Variable: | more

Eremua

PowerShell-eko aldagaiek Scope izeneko kontzeptua dute. Esparru globala uneko saio osoari aplikatzen zaio; adibidez, sistemaren aldagaiak barne hartzen ditu. Aldagai lokalak definitutako esparruan soilik daude eskuragarri: esate baterako, funtzio baten barruan. Script-esparruaren kontzeptua ere badago (Script), baina script komandoetarako funtsean lokala da. Lehenespenez, aldagaiak deklaratzean, esparru lokala ematen zaie, eta hau aldatzeko, honelako eraikuntza berezi bat behar duzu: $Global: aldagaia = balioa.

Adibidez, honela:

$Global:test = 100

Inguruko aldagaiak

PowerShell-en beste sasi-unitate bat dago eskuragarri, Env:, ingurune-aldagaietara sartzeko erabil dezakezuna. Shell abiarazten denean, prozesu nagusitik (hau da, uneko saioa hasi duen programatik) kopiatzen dira eta normalean hasierako balioak kontrol paneleko balioekin bat datoz. Ingurune-aldagaiak ikusteko, erabili Get-ChildItem cmdlet-a edo haren ezizenak: ls eta dir.

dir Env:

Aldagai hauek byte (edo karaktere, nahiago baduzu) segidak dira, eta horien interpretazioa erabiltzen dituen programaren araberakoa da soilik. *-Inguruko aldagaiak dituzten cmdlet aldagaiek ez dute funtzionatzen. Horiei erreferentzia egiteko, disko-aurrizkia erabili beharko duzu:

$env:TEST = "Hello, World!"

Aritmetika eta Konparazio Eragileak

PowerShellek operadore aritmetiko hauek ditu: + (baketa), - (kenketa), * (biderketa), / (zatiketa) eta % (moduloa edo zatiketaren hondarra). Adierazpen aritmetiko baten emaitza ezkerretik eskuinera ebaluatzen da orokorrean onartutako eragiketen ordenaren arabera, eta parentesiak erabiltzen dira adierazpenaren zatiak taldekatzeko. Eragileen arteko zuriuneak ez dira aintzat hartzen eta gauzak errazago irakurtzeko soilik erabiltzen dira. + eragileak ere kateatzen ditu, eta * eragileak kateak errepikatzen ditu. Zenbaki bat kate bati gehitzen saiatzen bazara, kate bihurtuko da. Horrez gain, PowerShell-ek konparazio-operadore asko ditu bi balio konparatzen dituztenak eta Boolear True edo False bat itzultzen dutenak:

operadorea

Description

Kode Adibidea

-ek

Berdin / Berdin (beste hizkuntza batzuetan = edo ==-ren analogoa)

$proba = 100
$test -eq 123

- da

Ez berdina / Ez berdina (<> edo !=-ren analogoa)

$proba = 100
$proba -ne 123

-gt

baino handiagoa/gehiago (analogikoa >)

$proba = 100
$test -gt 123

-ge

Handiagoa edo berdina / Handiagoa edo berdina (analogikoa >=)

$proba = 100
$test -ge 123

-lt

Gutxiago / Gutxiago (analogikoa <)

$proba = 100
$proba -lt 123

-la

baino txikiagoa edo berdina / Menos o igual (analógico <=)

$proba = 100
$proba -le 123

Badira antzeko beste operadore batzuk, adibidez, kateak komodinak erabiliz konparatzeko edo adierazpen erregularrak erabiltzea eredu batekin bat etortzeko. Hurrengo artikuluetan zehatz-mehatz aztertuko ditugu. <, > eta = ikurrak ez dira konparaziorako erabiltzen, beste helburu batzuetarako erabiltzen direlako.

Esleipen-eragileak

= Eragile arruntenaz gain, beste esleipen-operadore batzuk daude: +=, -=, *=, /= eta %=. Esleitu aurretik balioa aldatzen dute. Aldagai baten balioa handitzen edo txikitzen duten ++ eta - eragile unarioek antzera jokatzen dute - esleipen-operadoreei ere dagokie.

Operadore logikoak

Konparaketa bakarrik ez da nahikoa baldintza konplexuak deskribatzeko. Eragileak erabiliz edozein adierazpen logiko idatz dezakezu: -eta, -or, -xor, -not eta!... Beste programazio-lengoaia batzuetan bezala funtzionatzen dute, baina parentesiak erabil ditzakezu kalkulu-ordena zehazteko:

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

-not (123 -gt 321) 

!(123 -gt 321)

Baldintzazko jauzia

PowerShell-en adarkatze-operadoreak estandarrak dira: IF(IF...ELSE, IF...ELSEIF...ELSE) eta SWITCH. Ikus dezagun haien erabilera adibideekin:

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

Zikloak

PowerShellek hainbat begizta mota ditu: WHILE, DO WHILE, DO UNTIL, FOR eta FOREACH.

Aurrebaldintza duen begizta bat exekutatzen da egia bada/bitartean:

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

Postbaldintza duten begiztak gutxienez behin exekutatuko dira, iterazioa amaitu ondoren baldintza egiaztatzen delako. Kasu honetan, DO WHILE baldintza egia den bitartean funtzionatzen du eta DO UNTIL faltsua den bitartean:

[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 begiztaren iterazio kopurua aldez aurretik ezagutzen da:

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

FOREACH begiztan, array edo bilduma baten (hash taula) elementuak errepikatzen ditu:

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

Arrayak

PowerShell aldagaiek objektu bakarrak ez ezik (zenbakia, katea, etab.) gordetzen dituzte, baita hainbat objektu ere. Aldagai motarik errazena array-ak dira. Array bat hainbat elementuz osatuta egon daiteke, elementu bat edo hutsik egon, hau da. ez dute elementurik. Adierazteko, hurrengo artikuluan beharko dugun @() operadorea erabiltzen dugu; oso garrantzitsua da array bati beste array batzuk gehitzeko (dimentsio anitzeko matrizeak sortzeko), array funtzioetara argumentu gisa pasatzeko eta antzeko zereginetarako:

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

Array bat hastean, bere balioak komaz bereizita zerrendatzen dira (operadore berezia ,):

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

Kasu gehienetan, @() eragilea ezabatu daiteke:

$test_array = 1, 2, 3, 4

Kasu honetan, elementu bakarreko array bat hasieratzen da honela

$test_array = , 1

Array-elementuetara sartzeko, erabili zero-oinarritutako zenbaki osoen indizea eta indize-operadorea (kotxete karratuak):

$test_array[0] = 1

Hainbat indize zehaztu ditzakezu komaz bereizita, barne. errepikatuz:

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

operadorea .. (bi puntu - barruti operadorea) zenbaki osoen matrize bat itzultzen du zehaztutako goiko eta beheko muga batean. Adibidez, 1..4 adierazpenak lau elementuko array bat ateratzen du @(1, 2, 3, 4), eta 8..5 adierazpenak @(8, 7, 6, 5) array bat ateratzen du.

Barruti operadorea erabiliz, matrize bat hasieratu dezakezu ($test_array = 1..4) edo xerra bat lor dezakezu, hau da. array bateko elementuen sekuentzia beste baten indizeak dituena. Kasu honetan, -1 zenbaki negatiboak arrayaren azken elementua adierazten du, -2 - azkenaurrekoa, etab.

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

Kontuan izan zenbaki oso baten balioak datu-matrizearen gehienezko indize-balioa baino handiagoak izan daitezkeela. Kasu honetan, azkenera arteko balio guztiak itzultzen dira:

$test_array[0..100]

Existitzen ez den array-elementu bakar batera sartzen saiatzen bazara, $null balioa itzultzen da.

PowerShell-en, matrizeek mota ezberdinetako elementuak izan ditzakete edo biziki idatzita egon daitezke:

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

Non $test_array.count propietatea matrizeko elementuen kopurua den.

Oso idatzitako array bat sortzeko adibide bat:

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

Hash taulak

PowerShellen oinarrizko beste aldagai mota bat hash taulak dira, matrize elkartuak ere deitzen direnak. Hashtaulak JSON objektuen antzekoak dira eta gako-balioaren arabera eraikitzen dira. Matrize arruntak ez bezala, haien elementuak gako izendunen bidez atzitzen dira, objektuaren propietateak direnak (indize-operadorea ere erabil dezakezu - kortxete).

Hash-taula huts bat @ ikurra eta operadorearen parentesiak erabiliz deklaratzen da:

$test_hashtable = @{}

Adierazten duzunean, berehala sor ditzakezu gakoak eta haiei balioak esleitu:

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

Hash taulari elementu bat gehitzeko, oraindik existitzen ez den gako bat esleitu behar diozu edo Add() metodoa erabili. Lehendik dagoen gako bati esleipena egiten bazaio, haren balioa aldatuko da. Hash taulatik elementu bat kentzeko, erabili Remove() metodoa.

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

Mota honetako aldagaiak argumentu gisa pasa daitezke funtzioei eta cmdletei - hurrengo artikuluan hori nola egiten den aztertuko dugu eta antzeko beste mota bat ere aztertuko dugu - PSCustomObject.

funtzio

PowerShell-ek prozedurazko programaziorako behar duzun guztia dauka, funtzioak barne. Horiek deskribatzeko, zerbitzu-hitza Funtzioa erabiltzen da, ondoren funtzioaren izena eta gorputza operadoreen parentesi artean sartuta adierazi behar dituzu. Funtzioari argumentuak pasatu behar badituzu, parentesi artean izenaren ondoren berehala zehaztu daitezke.

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

Funtzioak beti itzultzen du emaitza bat - hau bere adierazpen guztien emaitzen array bat da, bat baino gehiago bada. Adierazpen bakarra badago, dagokion motako balio bakarra itzultzen da. $value itzulerak $value balioa duen elementu bat gehitzen dio emaitzen arrayari eta adierazpen-zerrendaren exekuzioa bertan behera uzten du, funtzio huts batek $null itzultzen duen bitartean.

Adibidez, sor dezagun zenbaki bat karraturako funtzio bat:

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

Kontuan izan funtzio baten gorputzean deitu aurretik deklaratutako edozein aldagai erabil dezakezula, eta PowerShell-en funtzioak deitzeak ezohikoa dirudi: argumentuak (halakorik badago) ez daude parentesi artean eta zuriunez bereizita daude.

sqr 2

edo honela:

sqr -number 2

Argumentuak pasatzen diren moduagatik, funtzioa bera batzuetan parentesi artean sartu behar da:

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

Funtzio bat deskribatzerakoan, balio lehenetsiak eslei diezazkiekezu argumentuei:

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

Funtzio argumentuak deskribatzeko beste sintaxi bat ere badago, eta parametroak kanalizaziotik ere irakur daitezke - hau guztia ondo etorriko zaigu hurrengo artikuluan, moduluak esportatzea eta zure cmdlet-ak sortzea aztertzen dugunean.

Errore bat prozesatzen

PowerShell-ek Try...Catch...Finly mekanismo bat du, salbuespen egoerak kudeatzeko aukera ematen duena. Try blokeak errore bat gerta daitekeen kodea du, eta Catch blokeak bere kudeatzailea du. Errorerik egon ez bada, ez da exekutatzen. Finally blokea Try blokearen ondoren exekutatzen da, erroreren bat gertatzen den ala ez kontuan hartu gabe, eta hainbat Catch bloke egon daitezke salbuespen mota desberdinetarako. Salbuespena bera deklaratu gabeko aldagai lehenetsi batean ($_) idazten da eta erraz berreskuratu daiteke. Beheko adibidean balio oker bat sartzearen aurkako babesa ezartzen dugu:

try {

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

} catch {

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

}

Hemen amaitu beharko genuke PowerShell-en programazioaren oinarrien berrikuspena. Etorkizuneko artikuluetan, sakonago aztertuko dugu mota ezberdinetako aldagaiak, bildumak, adierazpen erregularrak, funtzioak, moduluak eta zure cmdlet-ak sortzea, baita objektuetara zuzendutako programazioa ere.

Iturria: www.habr.com

Zer da Windows PowerShell eta zertarako erabiltzen da? 2. zatia: Programazio Lengoaiaren Sarrera