Yn hanesyddol, mae cyfleustodau llinell orchymyn ar systemau Unix wedi'u datblygu'n well nag ar Windows, ond gyda dyfodiad datrysiad newydd, mae'r sefyllfa wedi newid.
Gellir sgriptio PowerShell mewn iaith aml-paradeim wedi'i dehongli sydd ag elfennau o raglennu gweithdrefnol clasurol, gwrthrych-ganolog, a hyd yn oed swyddogaethol: canghennog amodol, dolenni, newidynnau, araeau, tablau stwnsh, dosbarthiadau, trin gwallau, yn ogystal â swyddogaethau, cmdlets, a phiblinellau . wedi'i neilltuo i hanfodion gweithio yn yr amgylchedd, a nawr rydym yn cynnig cyfeirlyfr bach ar gyfer rhaglenwyr i'n darllenwyr.
Gemau:
Gallwch ysgrifennu cod mewn unrhyw olygydd testun neu ddefnyddio amgylchedd datblygu integredig - y ffordd hawsaf yw cymryd Windows PowerShell ISE sy'n dod gyda systemau gweithredu gweinydd Microsoft. Dim ond ar gyfer sgriptiau gweddol gymhleth y mae angen hyn: mae setiau byr o orchmynion yn haws i'w gweithredu'n rhyngweithiol.
Sylwadau
Ystyrir bod defnyddio sylwadau yn rhan o arddull rhaglennu dda ynghyd â mewnoliad cywir a gofod gwyn:
# Для строчных комментариев используется символ решетки — содержимое строки интерпретатор не обрабатывает.
<#
Так обозначаются начало и конец блочного комментария.
Заключенный между ними текст интерпретатор игнорирует.
#>
Newidynnau a'u mathau
Mae newidynnau yn PowerShell yn wrthrychau a enwir. Gall eu henwau gynnwys y nod tanlinellu, yn ogystal â llythrennau a rhifau. Mae'r symbol $ yn cael ei ddefnyddio cyn yr enw bob amser, ac i ddatgan newidyn, mae'n ddigon i roi enw dilys i'r cyfieithydd:
I gychwyn newidyn (rhoi gwerth iddo), defnyddir gweithredwr yr aseiniad (symbol =):
$test = 100Gallwch ddatgan newidyn trwy nodi ei fath mewn cromfachau sgwâr (gweithredwr castio math) cyn yr enw neu'r gwerth:
[int]$test = 100
$test = [int]100Mae'n bwysig deall bod newidynnau yn PowerShell yn wrthrychau llawn (dosbarthiadau) gydag eiddo a dulliau y mae eu mathau yn seiliedig ar y rhai yn .NET Core. Rydym yn rhestru'r prif rai:
Math (. dosbarth NET)
Disgrifiad
Enghraifft Cod
[llinyn] System.StringLlinyn Unicode
$test = "prawf"
$test = 'prawf'
Nod Unicode (16 did)
[char]$test = 'c' [bool] System.Booleanmath boolean (boolean Gwir neu Gau)
[bool]$test = $true [int]System.Int32cyfanrif tri deg dau (32 did)
[int]$test = 123456789 [hir] System.Int64cyfanrif chwe deg pedwar did (64 did)
[hir]$prawf = 12345678910 [sengl] System.Singlerhif pwynt arnawf 32 did o hyd
[sengl]$test = 12345.6789 [dwbl]System.Dwblrhif pwynt arnawf o hyd 64 did (8 beit)
[dwbl]$prawf = 123456789.101112 [decimal] System.DegolRhif pwynt arnawf 128-did (sy'n ofynnol i orffen gyda d)
[degol]$prawf = 12345.6789d [DateTime]System.DateTimedyddiad ac amser
$test = GetDate
[arae] System.Object[]arae y mae ei fynegai elfennau yn dechrau ar 0
$test_array = 1, 2, "prawf", 3, 4
[hashtable] System.Collections.HashtableMae tablau hash yn araeau cysylltiadol gydag allweddi wedi'u henwi, wedi'u hadeiladu yn unol â'r egwyddor: @{key = "gwerth"}
$test_hashtable = @{one="one"; two = dau"; tri="tri"}
Mae PowerShell yn cefnogi trosi math ymhlyg, yn ogystal, gellir newid y math o newidyn ar y hedfan (er enghraifft, gan ddefnyddio gweithredwr aseiniad), os nad yw wedi'i nodi'n rymus - yn yr achos hwn, bydd y cyfieithydd yn rhoi gwall. Gallwch chi benderfynu ar y math o newidyn o'r enghraifft flaenorol trwy ffonio'r dull GetType ():
$test.GetType().FullName
Mae yna nifer o cmdlets ar gyfer trin newidynnau. Mae eu rhestr mewn ffurf gyfleus yn cael ei harddangos gan ddefnyddio'r gorchymyn:
Get-Command -Noun Variable | ft -Property Name, Definition -AutoSize -Wrap
I weld newidynnau datganedig a'u gwerthoedd, gallwch ddefnyddio cmdlet arbennig:
Get-Variable | moreMae'r dull hwn yn ymddangos yn or-feichus, mae'n llawer mwy cyfleus gweithio gyda newidynnau trwy weithredwyr neu trwy gyrchu eu priodweddau a'u dulliau yn uniongyrchol. Fodd bynnag, mae gan cmdlets hawl i fodoli oherwydd eu bod yn caniatáu ichi osod rhai paramedrau ychwanegol. Mae'n bwysig deall mai dim ond yn y sesiwn gyfredol y diffinnir newidynnau defnyddwyr. Pan fydd y consol ar gau neu pan ddaw'r sgript i ben, cânt eu dileu.
Newidynnau system
Yn ogystal â'r rhai a ddatganwyd gan y defnyddiwr, mae newidynnau adeiledig (system) nad ydynt yn cael eu dileu ar ôl i'r sesiwn gyfredol ddod i ben. Fe'u rhennir yn ddau fath, tra bod data cyflwr PowerShell yn cael ei storio mewn newidynnau awtomatig na ellir eu neilltuo gwerthoedd mympwyol ar eu pen eu hunain. Mae’r rhain yn cynnwys, er enghraifft, $PWD:
$PWD.Path
Mae angen newidynnau dewis i storio dewisiadau defnyddwyr, a gellir newid eu gwerthoedd. Er enghraifft, gan ddefnyddio $ErrorActionPreference , gosodir ymateb y dehonglydd gorchymyn i gamgymeriadau nad ydynt yn angheuol.
Yn ogystal â gweithredwyr a cmdlets ar gyfer cyrchu newidynnau datganedig, mae Newidyn: ffug-gronadur. Gallwch weithio gydag ef trwy gyfatebiaeth â gyriannau eraill, ac mae'r newidynnau yn yr achos hwn yn debyg i wrthrychau system ffeiliau:
Get-ChildItem Variable: | moreneu
ls Variable: | more
Cwmpas
Ar gyfer newidynnau yn PowerShell, mae cysyniad cwmpas (Cwmpas). Mae gweithred y cwmpas byd-eang (Byd-eang) yn berthnasol i'r sesiwn gyfredol gyfan - mae'n cynnwys, er enghraifft, newidynnau system. Mae newidynnau lleol (Lleol) ar gael yn unig yn y cwmpas lle cawsant eu diffinio: dyweder y tu mewn i ffwythiant. Mae yna hefyd y cysyniad o gwmpas y sgript (Sgript), ond ar gyfer gorchmynion sgript, mae'n ei hanfod yn lleol. Yn ddiofyn, wrth ddatgan newidynnau, rhoddir sgôp lleol iddynt, ac i newid hyn, mae angen lluniad arbennig arnoch fel: $Global: changen = gwerth.
Er enghraifft, fel hyn:
$Global:test = 100
Newidynnau amgylchedd (amgylchedd)
Mae ffug-yriant arall, Env:, ar gael gan PowerShell a gellir ei ddefnyddio i gael mynediad at newidynnau amgylchedd. Pan fydd y gragen yn dechrau, cânt eu copïo o'r broses rhiant (hynny yw, o'r rhaglen a gychwynnodd y sesiwn gyfredol) ac fel arfer mae eu gwerthoedd cychwynnol yr un fath â'r gwerthoedd yn y panel rheoli. I weld newidynnau amgylchedd, defnyddiwch y cmdlet Get-ChildItem neu ei aliasau (aliasau): ls a dir.
dir Env:
Mae'r newidynnau hyn yn ddilyniannau o beit (neu nodau, os mynnwch), y mae eu dehongliad yn dibynnu'n unig ar y rhaglen sy'n eu defnyddio. Nid yw'r cmdlets *-Amrywiadwy yn gweithio gyda newidynnau amgylchedd. I gael mynediad iddynt, mae'n rhaid i chi ddefnyddio'r rhagddodiad gyriant:
$env:TEST = "Hello, World!"
Gweithredwyr rhifyddeg a chymharu
Mae PowerShell yn darparu'r gweithredwyr rhifyddeg canlynol: + (ychwanegiad), - (tynnu), * (lluosi), / (rhaniad), a % (modulo neu fodulo). Mae canlyniad mynegiant rhifyddol yn cael ei werthuso o'r chwith i'r dde yn unol â'r drefn weithrediadau a dderbynnir yn gyffredinol, a defnyddir cromfachau i grwpio rhannau o'r mynegiant. Anwybyddir bylchau rhwng gweithredwyr, dim ond i'w gwneud yn haws i'w darllen y cânt eu defnyddio. Mae'r gweithredwr + hefyd yn cydgadwynu, ac mae'r gweithredwr * yn ailadrodd llinynnau. Os ceisiwch ychwanegu rhif at linyn, caiff ei drosi i linyn. Yn ogystal, mae gan yr iaith PowerShell lawer o weithredwyr cymhariaeth sy'n gwirio am gydweddiad rhwng dau werth ac yn dychwelyd y boolean Gwir neu Gau:
Gweithredwr
Disgrifiad
Enghraifft Cod
-eq
Cyfartal / Cyfartal (tebyg i = neu == mewn ieithoedd eraill)
$prawf = 100
$ prawf -eq 123
- yn
Ddim yn gyfartal / Ddim yn gyfartal (tebyg i <> neu !=)
$prawf = 100
$prawf -ne 123
-gt
Mwy na / Mwy (analog>)
$prawf = 100
$prawf -gt 123
-ge
Mwy na neu'n hafal / Mwy na neu'n hafal (tebyg i >=)
$prawf = 100
$prawf -ge 123
-lt
Llai na / Llai (tebyg i <)
$prawf = 100
$prawf -lt 123
-y
Llai na neu hafal / Llai na neu hafal (tebyg i <=)
$prawf = 100
$prawf -le 123
Mae yna weithredwyr tebyg eraill sy'n caniatáu i chi, er enghraifft, gymharu llinynnau yn seiliedig ar gerdyn gwyllt neu ddefnyddio ymadroddion rheolaidd i gyd-fynd â phatrwm. Byddwn yn ymdrin â nhw'n fanwl mewn erthyglau yn y dyfodol. Nid yw'r symbolau <, > a = yn cael eu defnyddio i gymharu oherwydd eu bod yn cael eu defnyddio at ddibenion eraill.
Gweithredwyr aseiniadau
Yn ogystal â'r gweithredwr = mwyaf cyffredin, mae yna weithredwyr aseiniadau eraill: +=, -=, *=, /= a %=. Maent yn newid y gwerth cyn aseiniad. Mae'r gweithredwyr unary ++ a -, sy'n cynyddu neu'n lleihau gwerth newidyn, yn ymddwyn yn debyg - maent hefyd yn berthnasol i weithredwyr aseiniadau.
Gweithredwyr rhesymegol
Nid yw cymhariaeth yn unig yn ddigon i ddisgrifio amodau cymhleth. Gallwch ysgrifennu unrhyw ymadroddion rhesymegol gan ddefnyddio'r gweithredwyr: -a, -or, -xor, -not a! .. Maen nhw'n gweithio fel mewn ieithoedd rhaglennu eraill, tra gallwch chi ddefnyddio cromfachau i nodi trefn y gwerthusiad:
("Тест" -eq "Тест") -and (100 -eq 100)
-not (123 -gt 321)
!(123 -gt 321)
Naid Amodol
Mae gweithredwyr cangen yn PowerShell yn safonol: IF(IF…ELSE, IF…ELSEIF…ELSE) a SWITCH. Edrychwn ar eu defnydd gydag enghreifftiau:
[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 или значение не определено"}
}
Beiciau
Mae gan PowerShell sawl math o ddolenni: WILE, DO WILE, DO TAN, FOR, a FOREACH.
Mae dolen gyda rhagamod yn gweithio os/cyhyd â'i fod yn wir:
[int]$test = 0
while ($test -lt 10) {
Write-Host $test
$test = $test + 1
}
Bydd dolenni â chyflwr post yn rhedeg o leiaf unwaith, oherwydd bod y cyflwr yn cael ei wirio ar ôl yr iteriad. Ar yr un pryd, DO WILE yn gweithio tra bod y cyflwr yn wir, a PEIDIWCH TAN yn gweithio tra ei fod yn ffug:
[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)
Mae nifer yr iteriadau o'r ddolen FOR yn hysbys ymlaen llaw:
for ([int]$test = 0; $test -lt 10; $test++) {
Write-Host $test
}
Yn y ddolen FOREACH, mae'n ailadrodd trwy elfennau arae neu gasgliad (tabl hash):
$test_collection = "item1", "item2", "item3"
foreach ($item in $test_collection)
{
Write-Host $item
}
Araeau
Mae newidynnau PowerShell yn storio nid yn unig gwrthrychau sengl (rhif, llinyn, ac ati), ond hefyd rhai lluosog. Y math symlaf o newidynnau o'r fath yw araeau. Gall arae gynnwys sawl elfen, un elfen, neu fod yn wag, h.y. yn cynnwys dim elfennau. Fe'i datgenir gan ddefnyddio'r gweithredwr @(), y bydd ei angen arnom yn yr erthygl nesaf - mae'n bwysig iawn ychwanegu araeau eraill at arae (creu araeau aml-ddimensiwn), trosglwyddo araeau i swyddogaethau fel dadl, a thasgau tebyg:
$test_array = @() #создаем пустой массивPan ddechreuir arae, rhestrir ei gwerthoedd wedi'u gwahanu gan atalnodau (gweithredwr arbennig ,):
$test_array = @(1, 2, 3, 4) # создаем массив из четырех элементов Yn y rhan fwyaf o achosion, gellir hepgor y gweithredwr @():
$test_array = 1, 2, 3, 4Yn yr achos hwn, dechreuir cyfres o un elfen fel a ganlyn
$test_array = , 1Ceir mynediad i elfennau arae gan ddefnyddio mynegai cyfanrif sero a gweithredwr y mynegai (cromfachau sgwâr):
$test_array[0] = 1Gallwch nodi nifer o fynegai wedi'u gwahanu gan atalnodau, gan gynnwys. cylchol:
$test_array = "один", "два", "три", "четыре"
$test_array[0,1,2,3]
$test_array[1,1,3,3,0]
Gweithredwr .. (dau ddot - gweithredwr amrediad) yn dychwelyd amrywiaeth o gyfanrifau o fewn y terfynau uchaf ac isaf penodedig. Er enghraifft, mae mynegiant 1..4 yn allbynnu arae o bedair elfen @(1, 2, 3, 4), ac mae mynegiant 8..5 yn allbynnu arae @(8, 7, 6, 5).
Gan ddefnyddio gweithredwr yr ystod, gallwch gychwyn arae ($test_array = 1..4) neu gael tafell (tafell), h.y. dilyniant o elfennau o un arae gyda mynegeion o un arall. Yn yr achos hwn, mae rhif negyddol -1 yn dynodi elfen olaf yr arae, -2 - yr un olaf ond un, ac yn y blaen.
$test_array = "один", "два", "три", "четыре"
$test_array[0..2]
$test_array[2..0]
$test_array[-1..0]
$test_array[-2..1]Sylwch y gall gwerthoedd arae cyfanrif fod yn fwy na gwerth mynegai uchaf yr arae ddata. Yn yr achos hwn, dychwelir yr holl werthoedd hyd at yr un olaf:
$test_array[0..100]Os ceisiwch gyrchu un elfen arae nad yw'n bodoli, dychwelir $null.
Yn PowerShell, gall araeau gynnwys elfennau o wahanol fathau neu gael eu teipio'n gryf:
$test_array = 1, 2, "тест", 3, 4
for ([int]$i = 0; $i -lt $test_array.count; $i++)
{
Write-Host $test_array[$i]
}
Lle mae'r priodwedd $test_array.count yw nifer yr elfennau arae.
Enghraifft o greu arae wedi'i deipio'n gryf:
[int[]]$test_array = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
Byrddau hash
Math sylfaenol arall o newidyn yn PowerShell yw tablau stwnsh, a elwir hefyd yn araeau cysylltiadol. Mae tablau hash yn debyg i wrthrychau JSON ac wedi'u hadeiladu ar sail gwerth allweddol. Yn wahanol i araeau rheolaidd, gellir cyrchu eu helfennau gan ddefnyddio allweddi a enwir, sef priodweddau'r gwrthrych (gallwch hefyd ddefnyddio'r gweithredwr mynegai - cromfachau sgwâr).
Mae tabl stwnsh gwag yn cael ei ddatgan gan ddefnyddio'r symbol @ a'r cromfachau gweithredwr:
$test_hashtable = @{}Wrth ddatgan, gallwch greu allweddi ar unwaith a phennu gwerthoedd iddynt:
$test_hashtable = @{one="один"; two="два"; three="три"; "some key"="some value"}I ychwanegu elfen at dabl hash, rhaid i chi aseinio allwedd nad yw'n bodoli iddo eto, neu ddefnyddio'r dull Ychwanegu (). Os gwneir aseiniad i allwedd sy'n bodoli eisoes, bydd ei werth yn newid. Defnyddir y dull Dileu() i dynnu elfen o dabl stwnsh.
$test_hashtable."some key"
$test_hashtable["some key"]
$test_hashtable.Add("four", "четыре")
$test_hashtable.five = "пять"
$test_hashtable['five'] = "заменяем значение"
$test_hashtable.Remove("one")
Gellir trosglwyddo newidynnau o'r math hwn fel dadleuon i swyddogaethau a cmdlets - yn yr erthygl nesaf byddwn yn astudio sut y gwneir hyn, a hefyd yn ystyried math tebyg arall - PSCustomObject.
Swyddogaethau
Mae gan PowerShell bopeth sydd ei angen arnoch ar gyfer rhaglennu gweithdrefnol, gan gynnwys swyddogaethau. Er mwyn eu disgrifio, defnyddir y gair swyddogaeth Swyddogaeth, ac ar ôl hynny mae angen i chi nodi enw'r swyddogaeth a'r corff sydd wedi'i amgáu mewn cromfachau gweithredwr. Os oes angen i chi drosglwyddo dadleuon i'r swyddogaeth, gallwch eu nodi yn syth ar ôl yr enw mewn cromfachau.
function имя-функции (аргумент1, ..., аргументN)
{
тело-функции
}
Mae'r swyddogaeth bob amser yn dychwelyd canlyniad - mae'n amrywiaeth o ganlyniadau ei holl ddatganiadau, os oes mwy nag un. Os mai dim ond un datganiad sydd, dychwelir unig werth y math cyfatebol. Mae'r dychweliad $value construct yn ychwanegu elfen gyda'r gwerth $value i'r arae canlyniadau ac yn erthylu gweithrediad y rhestr datganiadau, ac mae'r ffwythiant gwag yn dychwelyd $null.
Er enghraifft, gadewch i ni greu swyddogaeth ar gyfer sgwario rhif:
function sqr ($number)
{
return $number * $number
}
Sylwch, yng nghorff swyddogaeth, y gallwch chi ddefnyddio unrhyw newidynnau a ddatganwyd cyn ei alw, a gall swyddogaethau galw yn PowerShell ymddangos yn anarferol: nid yw'r dadleuon (os o gwbl) wedi'u hamgáu mewn cromfachau ac maent wedi'u gwahanu gan fylchau.
sqr 2neu felly:
sqr -number 2Oherwydd y ffordd y mae dadleuon yn cael eu pasio, weithiau mae angen amgáu'r swyddogaeth ei hun mewn cromfachau:
function test_func ($n) {}
test_func -eq $null # функция не вызывалась
(test_func) -eq $null # результат выражения — $true
Wrth ddisgrifio swyddogaeth, gallwch aseinio gwerthoedd rhagosodedig i ddadleuon:
function func ($arg = value) {
#тело функции
}
Mae cystrawen arall ar gyfer disgrifio dadleuon swyddogaeth, yn ogystal, gellir darllen paramedrau o'r biblinell - bydd hyn i gyd yn dod yn ddefnyddiol yn yr erthygl nesaf, pan fyddwn yn edrych ar fodiwlau wedi'u hallforio a chreu ein cmdlets ein hunain.
Prosesu gwallau
Mae gan PowerShell fecanwaith Try...Catch...Yn olaf, i ymdrin ag eithriadau. Mae'r bloc Try yn cynnwys y cod lle gall gwall ddigwydd, ac mae'r bloc Dal yn cynnwys ei driniwr. Os nad oedd gwall, nid yw'n cael ei weithredu. Mae'r bloc Yn olaf yn cael ei weithredu ar ôl y bloc Try, waeth beth fo gwall, a gall fod sawl bloc Dal ar gyfer gwahanol fathau o eithriadau. Mae'r eithriad ei hun wedi'i ysgrifennu i newidyn rhagosodedig heb ei ddatgan ($ _) a gellir ei adfer yn hawdd. Yn yr enghraifft isod, rydym yn gweithredu amddiffyniad rhag mynd i mewn i werth annilys:
try {
[int]$test = Read-Host "Введите число"
100 / $test
} catch {
Write-Warning "Некорректное число"
Write-Host $_
}
Mae hyn yn cloi'r adolygiad o hanfodion rhaglennu yn iaith PowerShell. Yn yr erthyglau canlynol, byddwn yn astudio'n fanylach gan weithio gyda newidynnau o wahanol fathau, casgliadau, ymadroddion rheolaidd, creu swyddogaethau, modiwlau a cmdlets arfer, yn ogystal â rhaglennu gwrthrych-ganolog.
Ffynhonnell: hab.com