🥇 Cad é Windows PowerShell agus cad leis a itear é? Cuid 2: Buneolas ar an teanga ríomhchlárúcháin

Go stairiúil, tá forbairt níos fearr ar fhóntais ordú-líne ar chórais Unix ná ar Windows, ach le teacht ar réiteach nua, tá athrú tagtha ar an scéal.

Is féidir PowerShell a scríobh i dteanga léirmhínithe, ilpharadach a bhfuil gnéithe de ríomhchlárú clasaiceach nós imeachta, dírithe ar oibiachtaí agus fiú feidhmiúil ann: brainseach coinníollach, lúba, athróga, eagair, táblaí hais, ranganna, láimhseáil earráidí, chomh maith le feidhmeanna, cmdlets, agus píblínte . Alt roimhe seo dírithe ar na bunghnéithe a bhaineann le bheith ag obair sa timpeallacht, agus anois cuirimid leabhar tagartha beag do ríomhchláraitheoirí ar fáil dár léitheoirí.

Suil:

Comments
Athróga agus a gcineálacha
Athróga córais
Scóip
Athróga timpeallachta (comhshaol)
Oibreoirí uimhríochta agus comparáide
Oibreoirí sannacháin
Oibreoirí loighciúla
Léim Coinníollach
Rothair
Arrays
Táblaí hash
Feidhmeanna
Earráid a phróiseáil

Is féidir leat cód a scríobh in aon eagarthóir téacs nó úsáid a bhaint as timpeallacht forbartha comhtháite - is é an bealach is éasca ná an ISE Windows PowerShell a thagann le córais oibriúcháin freastalaí Microsoft a ghlacadh. Níl sé seo riachtanach ach le haghaidh scripteanna measartha casta: tá sé níos éasca tacair ghearra orduithe a fhorghníomhú go hidirghníomhach.

Comments

Meastar gur cuid de dhea-stíl ríomhchláraithe é tráchtanna a úsáid mar aon le eangú cuí agus spás bán:

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

<# 

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

#>

Athróga agus a gcineálacha

Rudaí a thugtar ar athróga i PowerShell. Is féidir an carachtar foscór, chomh maith le litreacha agus uimhreacha, a áireamh ina n-ainmneacha. Úsáidtear an tsiombail $ roimh an ainm i gcónaí, agus chun athróg a dhearbhú, is leor ainm bailí a thabhairt don ateangaire:

Chun athróg a thúsú (sann luach di), úsáidtear an t-oibreoir sannacháin (siombail =):

$test = 100

Féadfaidh tú athróg a dhearbhú trína cineál a shonrú idir lúibíní cearnacha (oibreoir cineál réitigh) roimh an ainm nó an luach:

[int]$test = 100

$test = [int]100

Tá sé tábhachtach a thuiscint gur réada lán-chuimsitheach (ranganna) iad athróga i PowerShell le hairíonna agus modhanna a bhfuil a gcineálacha bunaithe orthu siúd i .NET Core. Liostaímid na príomhchinn:

Cineál (rang .NET)

Cur síos

Sampla Cód

[teaghrán] System.String

Teaghrán Unicode

$test = "tástáil"
$test = 'tástáil'

[char]Córas.Char

Carachtar Unicode (16 giotán)

[char]$test = 'c'

[bool] Córas.Boolean

cineál boolean (boolean Fíor nó Bréagach)

[bool]$test = $true

[int]Córas.Int32

slánuimhir tríocha dó giotán (32 giotán)

[int]$tástáil = 123456789

[fada]Córas.Int64

slánuimhir seasca ceathair (64 giotán)

[fada]$tástáil = 12345678910

[singil] Córas.Single

uimhir snámhphointe 32 giotán ar fad

[singil]$test = 12345.6789

[dúbailte]Córas.Double

líon snámhphointe ar fhad 64 giotán (8 bytes)

[dúbailte]$test = 123456789.101112

[deicheach]Córas.Deachúil

Uimhir snámhphointe 128-giotán (riachtanach chun deireadh a chur le d)

[deachúil]$tástáil = 12345.6789d

[DateTime]Córas.DateTime

dáta agus am

$test = GetDate

[eagar] Córas.Réad[]

eagar a thosaíonn a innéacs eiliminte ag 0

$test_array = 1, 2, "tástáil", 3, 4

[hashtable] System.Collections.Hashtable

is eagair chomhthiomsaitheach iad táblaí hais le heochracha ainmnithe, tógtha de réir an phrionsabail: @{ eochair = "luach"}

$test_hashtable = @{one="one"; dhá = a dó"; trí="trí"}

Tacaíonn PowerShell le comhshó cineál intuigthe, ina theannta sin, is féidir an cineál athróg a athrú ar an eitilt (mar shampla, ag baint úsáide as oibreoir sannta), mura bhfuil sé sonraithe go forneartach - sa chás seo, tabharfaidh an t-ateangaire earráid. Is féidir leat cineál na hathróige a chinneadh ón sampla roimhe seo ach glaoch ar an modh GetType():

$test.GetType().FullName

Tá roinnt cmdlets ann chun athróga a ionramháil. Taispeántar a liosta i bhfoirm áisiúil ag baint úsáide as an ordú:

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

Chun athróga dearbhaithe agus a luachanna a fheiceáil, is féidir leat cmdlet speisialta a úsáid:

Get-Variable | more

Is cosúil go bhfuil an modh seo ró-chasta, tá sé i bhfad níos áisiúla oibriú le hathróga trí oibreoirí nó trí rochtain a fháil ar a n-airíonna agus a modhanna go díreach. Mar sin féin, tá sé de cheart ag cmdlets a bheith ann toisc go gceadaíonn siad duit roinnt paraiméadair bhreise a shocrú. Tá sé tábhachtach a thuiscint nach sainítear athróga úsáideora ach amháin laistigh den seisiún reatha. Nuair a dhúntar an consól nó nuair a chríochnaíonn an script, scriostar iad.

Athróga córais

Chomh maith leo siúd atá dearbhaithe ag an úsáideoir, tá athróga ionsuite (córais) ann nach scriostar tar éis don seisiún reatha críochnú. Tá siad roinnte ina dhá chineál, agus stóráiltear sonraí stáit PowerShell in athróga uathoibríocha nach féidir luachanna treallach a shannadh dóibh féin. Áirítear orthu seo, mar shampla, $PWD:

$PWD.Path

Tá gá le hathróga tosaíochta chun sainroghanna úsáideoirí a stóráil, ar féidir a luachanna a athrú. Mar shampla, ag baint úsáide as $ErrorActionPreference , socraítear freagairt an ateangaire ordaithe maidir le tarlú earráidí neamh-mharfacha.

Chomh maith le hoibreoirí agus cmdlets chun rochtain a fháil ar athróga dearbhaithe, tá Athróg: pseudo-accumulator. Is féidir leat oibriú leis de réir analaí le tiomántáin eile, agus tá na hathróga sa chás seo cosúil le réada an chórais comhad:

Get-ChildItem Variable: | more

nó

ls Variable: | more

Scóip

Maidir le hathróga i PowerShell, tá coincheap an raoin (Scóip). Baineann gníomh an raon feidhme domhanda (Domhanda) leis an seisiún reatha iomlán - áirítear leis, mar shampla, athróga córais. Níl athróga áitiúla (Áitiúla) ar fáil ach amháin sa raon feidhme inar sainíodh iad: abair taobh istigh d’fheidhm. Tá coincheap scóip na scripte (Script) ann freisin, ach i gcás orduithe scripte, tá sé áitiúil go bunúsach. De réir réamhshocraithe, nuair a bhíonn athróga á ndearbhú, tugtar raon feidhme áitiúil dóibh, agus chun é seo a athrú, beidh tógáil speisialta uait mar: $Global: athróg = luach.

Mar shampla, mar seo:

$Global:test = 100

Athróga timpeallachta (comhshaol)

Tá tiomáint bhréige eile, Env:, ar fáil ó PowerShell agus is féidir é a úsáid chun teacht ar athróga timpeallachta. Nuair a thosaíonn an bhlaosc, déantar iad a chóipeáil ón bpróiseas tuismitheora (is é sin, ón gclár a chuir tús leis an seisiún reatha) agus de ghnáth tá a luachanna tosaigh mar an gcéanna leis na luachanna sa phainéal rialaithe. Chun athróga timpeallachta a fheiceáil, úsáid cmdlet Get-ChildItem nó a ailiasanna (ailiasanna): ls and dir.

dir Env:

Is seichimh beart (nó carachtair, más mian leat) iad na hathróga seo agus braitheann a léirmhíniú ar an gclár a úsáideann iad amháin. Ní oibríonn na cmdlets *-Athróg le hathróga timpeallachta. Chun iad a rochtain, caithfidh tú an réimír tiomántán a úsáid:

$env:TEST = "Hello, World!"

Oibreoirí uimhríochta agus comparáide

Soláthraíonn PowerShell na hoibreoirí uimhríochta seo a leanas: + (suimiú), - (dealú), * (iolrú), / (roinn), agus % (modulo nó modulo). Déantar toradh slonn uimhríochtúil a mheas ó chlé go deas de réir ord na n-oibríochtaí a nglactar leis go ginearálta, agus úsáidtear lúibíní chun codanna den slonn a ghrúpáil. Déantar neamhaird de spásanna idir oibreoirí, ní úsáidtear iad ach chun é a dhéanamh níos éasca le léamh. Comhcheanglaíonn an t-oibreoir + freisin, agus déanann an t-oibreoir * teaghráin arís. Má dhéanann tú iarracht uimhir a chur le teaghrán, tiontófar go teaghrán í. Ina theannta sin, tá go leor oibreoirí comparáide ag an teanga PowerShell a sheiceáil le haghaidh cluiche idir dhá luach agus a thugann an boolean Fíor nó Bréagach ar ais:

Oibreoir

Cur síos

Sampla Cód

-eq

Comhionann / Comhionann (cosúil le = nó == i dteangacha eile)

$tástáil = 100
$tástáil - cothrom 123

- tá

Níl sé comhionann / Níl sé comhionann (cosúil le <> nó !=)

$tástáil = 100
$tástáil -ne 123

-gt

Níos mó ná / Níos mó (analóg >)

$tástáil = 100
$triail -gt 123

-ge

Níos mó ná nó cothrom / Níos mó ná nó cothrom (cosúil le >=)

$tástáil = 100
$triail -ge 123

-lt

Níos lú ná / Níos lú (cosúil le <)

$tástáil = 100
$triail -lt 123

-the

Níos lú ná nó cothrom / Níos lú ná nó cothrom (cosúil le <=)

$tástáil = 100
$triail -le 123

Tá oibritheoirí cosúla eile ann a ligeann duit, mar shampla, teaghráin bunaithe ar chárta saoróige a chur i gcomparáid nó úsáid a bhaint as nathanna rialta chun patrún a mheaitseáil. Clúdóimid iad go mion in ailt amach anseo. Ní úsáidtear na siombailí <, > agus = chun comparáid a dhéanamh toisc go n-úsáidtear iad chun críocha eile.

Oibreoirí sannacháin

Chomh maith leis an oibreoir = is coitianta, tá oibreoirí sannacháin eile: +=, -=, *=, /= agus %=. Athraíonn siad an luach roimh sannadh. Iompraíonn na hoibreoirí unary ++ agus -, a mhéadaíonn nó a laghdaíonn luach athróige, iad féin mar an gcéanna - baineann siad freisin le hoibreoirí sannacháin.

Oibreoirí loighciúla

Ní leor comparáid amháin chun cur síos a dhéanamh ar choinníollacha casta. Is féidir leat aon nathanna loighciúla a scríobh ag baint úsáide as na hoibreoirí: -agus, -nó, -xor, -ní agus!

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

-not (123 -gt 321) 

!(123 -gt 321)

Léim Coinníollach

Tá oibritheoirí brainse i PowerShell caighdeánach: IF(IF…ELSE, IF…ELSEIF…ELSE) agus SWITCH. Breathnaímid ar a n-úsáid le samplaí:

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

Rothair

Tá roinnt cineálacha lúb ag PowerShell: WILE, DO WHILE, DO GO DTÍ, FOR, agus FOREACH.

Oibríonn lúb le réamhchoinníoll má/chomh fada agus atá sé fíor:

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

Rithfidh lúba a bhfuil iarchoinníoll orthu uair amháin ar a laghad, toisc go ndéantar an riocht a sheiceáil tar éis an atriallta. Ag an am céanna, oibríonn DO WHILE cé go bhfuil an riocht fíor, agus oibríonn DO GO DTÍ cé go bhfuil sé bréagach:

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

Tá líon atriallta na lúb FOR ar eolas roimh ré:

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

Sa lúb FOREACH, déantar athrá ar ghnéithe eagar nó bailiúcháin (tábla hash):

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

Arrays

Stórálann athróga PowerShell ní hamháin rudaí aonair (líon, teaghrán, etc.), ach freisin cinn iolracha. Is iad na cineálacha athróg is simplí ná eagair. Féadfaidh eagar a bheith comhdhéanta de roinnt gnéithe, eilimint amháin, nó a bheith folamh, i.e. nach bhfuil aon eilimintí. Dearbhaítear é ag baint úsáide as an oibreoir @(), a bheidh ag teastáil uainn sa chéad alt eile - tá sé an-tábhachtach chun eagair eile a chur le sraith (eagair iltoiseacha a chruthú), eagair a chur ar aghaidh chuig feidhmeanna mar argóint, agus tascanna comhchosúla:

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

Nuair a thosaítear eagar, liostaítear a luachanna scartha le camóga (oibreoir speisialta ,):

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

I bhformhór na gcásanna, is féidir an t-oibreoir @() a fhágáil ar lár:

$test_array = 1, 2, 3, 4

Sa chás seo, cuirtear tús le sraith d'eilimint amháin mar seo a leanas

$test_array = , 1

Faightear rochtain ar eilimintí eagar ag baint úsáide as innéacs slánuimhir nialasach agus an t-oibreoir innéacs (lúibíní cearnacha):

$test_array[0] = 1

Is féidir leat roinnt innéacsanna a shonrú scartha le camóga, lena n-áirítear. athfhillteach:

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

Oibreoir .. (dhá phonc - oibreoir raoin) cuireann sé raon slánuimhreacha ar ais laistigh de na teorainneacha sonraithe uachtaracha agus íochtaracha. Mar shampla, aschuir slonn 1..4 sraith ceithre eilimint @(1, 2, 3, 4), agus aschuir slonn 8..5 eagar @(8, 7, 6, 5).

Trí úsáid a bhaint as oibreoir an raoin, is féidir leat eagar a thúsú ($test_array = 1..4) nó slisne (slice) a fháil, i.e. seicheamh eilimintí ó eagar amháin le hinnéacsanna ó eagar eile. Sa chás seo, seasann uimhir dhiúltach -1 an eilimint dheireanach den eagar, -2 - an leathdhéanach, agus mar sin de.

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

Tabhair faoi deara gur féidir le luachanna eagair sláine a bheith níos mó ná uasluach innéacs an eagar sonraí. Sa chás seo, cuirtear na luachanna go léir ar ais suas go dtí an ceann deireanach:

$test_array[0..100]

Má dhéanann tú iarracht rochtain a fháil ar eilimint eagair amháin nach bhfuil ann, cuirfear $null ar ais.

I PowerShell, is féidir gnéithe de chineálacha éagsúla a bheith in eagair nó is féidir iad a chlóscríobh go láidir:

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

Nuair is ionann an t-airí $test_array.count agus líon na n-eilimintí eagar.

Sampla de eagar clóscríofa láidir a chruthú:

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

Táblaí hash

Athróg bhunúsach eile sa teanga PowerShell is ea táblaí hash, ar a dtugtar eagair chomhthiomsaitheach freisin. Tá hashtables cosúil le réada JSON agus tógtar iad ar bhonn eochairluacha. Murab ionann agus gnáth-eagair, déantar rochtain ar a n-eilimintí le heochracha ainmnithe, arb iad airíonna an ruda iad (is féidir leat an t-oibreoir innéacs a úsáid freisin - lúibíní cearnacha).

Dearbhaítear tábla hash folamh ag baint úsáide as an siombail @ agus lúibíní oibreora:

$test_hashtable = @{}

Agus tú ag dearbhú, is féidir leat eochracha a chruthú láithreach agus luachanna a shannadh dóibh:

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

Chun eilimint a chur le tábla hash, ní mór duit eochair nach bhfuil ann go fóill a shannadh dó, nó an modh Add () a úsáid. Má dhéantar sannadh d'eochair atá ann cheana féin, athrófar a luach. Úsáidtear an modh Bain() chun eilimint a bhaint as tábla hais.

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

Is féidir athróga den chineál seo a chur ar aghaidh mar argóintí chuig feidhmeanna agus cmdlets - sa chéad alt eile déanfaimid staidéar ar conas a dhéantar é seo, agus breithnímid freisin ar chineál eile den chineál céanna - PSCustomObject.

Feidhmeanna

Tá gach rud atá uait ag PowerShell le haghaidh ríomhchlárú nós imeachta, lena n-áirítear feidhmeanna. Chun cur síos a dhéanamh orthu, úsáidtear an focal feidhm Feidhm, agus ina dhiaidh sin ní mór duit ainm na feidhme agus an comhlacht atá faoi iamh idir lúibíní oibreora a shonrú. Más gá duit argóintí a chur ar aghaidh chuig an bhfeidhm, is féidir leat iad a shonrú díreach i ndiaidh an ainm i lúibíní.

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

Tugann an fheidhm toradh ar ais i gcónaí - is sraith é de thorthaí a ráitis go léir, má tá níos mó ná ceann amháin ann. Mura bhfuil ach ráiteas amháin ann, cuirtear an t-aon luach den chineál comhfhreagrach ar ais. Cuireann an tuairisceán $value construct eilimint leis an luach $value leis an eagar torthaí agus toirmíonn sé feidhmiú liosta na ráiteas, agus filleann an fheidhm folamh $null.

Mar shampla, cruthaimis feidhm chun uimhir a chearnú:

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

Tabhair faoi deara, i gcorp feidhme, gur féidir leat aon athróg a dhearbhaítear roimh ghlaoch air a úsáid, agus d'fhéadfadh go mbeadh cuma neamhghnách ar fheidhmeanna glaonna i PowerShell: níl na hargóintí (más ann dóibh) faoi iamh i lúibíní agus tá siad scartha le spásanna.

sqr 2

nó mar sin:

sqr -number 2

Mar gheall ar an mbealach a ritear argóintí, uaireanta is gá an fheidhm féin a chur faoi iamh i lúibíní:

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

Agus tú ag cur síos ar fheidhm, is féidir leat luachanna réamhshocraithe a shannadh d’argóintí:

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

Tá comhréir eile ann chun cur síos a dhéanamh ar argóintí feidhm, ina theannta sin, is féidir paraiméadair a léamh ón bpíblíne - beidh sé seo go léir áisiúil sa chéad alt eile, nuair a fhéachaimid ar mhodúil onnmhairithe agus ár cmdlets féin a chruthú.

Earráid a phróiseáil

Tá triail ag PowerShell...Catch...Sa deireadh meicníocht chun eisceachtaí a láimhseáil. Tá an cód inar féidir earráid tarlú sa bhloc Bain triail as, agus tá a láimhseálaí sa bhloc Gabhála. Mura raibh aon earráid ann, ní dhéantar é a fhorghníomhú. Déantar an bloc Ar deireadh a fhorghníomhú tar éis an bhloc Bain triail as, beag beann ar earráid a tharla, agus is féidir go mbeadh roinnt bloic Gabhála ann do chineálacha éagsúla eisceachtaí. Scríobhtar an eisceacht féin chuig athróg réamhshocraithe neamhdhearbhaithe ($ _) agus is féidir í a aisghabháil go héasca. Sa sampla thíos, cuirimid cosaint i bhfeidhm ar iontráil luach neamhbhailí:

try {

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

} catch {

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

}

Críochnaíonn sé seo an t-athbhreithniú ar bhunghnéithe an chláir sa teanga PowerShell. Sna hailt seo a leanas, déanfaimid staidéar níos mine ar oibriú le hathróga de chineálacha éagsúla, bailiúcháin, nathanna rialta, ag cruthú feidhmeanna, modúil agus cmdlets saincheaptha, chomh maith le ríomhchlárú atá dírithe ar oibiachtaí.

Foinse: will.com

Cad é Windows PowerShell agus cad a itear leis? Cuid 2: Réamhrá don teanga ríomhchlárúcháin