Ki sa ki Windows PowerShell ak kisa li manje? Pati 2: Entwodiksyon nan langaj pwogramasyon an

Istorikman, sèvis piblik liy kòmand sou sistèm Unix yo pi byen devlope pase sou Windows, men ak avenman nan yon nouvo solisyon, sitiyasyon an te chanje.

PowerShell ka fè script nan yon langaj entèprete, milti-paradigm ki gen eleman nan pwogram klasik pwosedi, oryante objè, e menm fonksyonèl: branch kondisyonèl, bouk, varyab, etalaj, tab hash, klas, manyen erè, osi byen ke fonksyon, cmdlets, ak tiyo . Atik anvan an te konsakre nan Basics yo nan travay nan anviwònman an, epi kounye a nou ofri lektè nou yo yon ti liv referans pou pwogramè yo.

Table of contents:

Kòmantè
Varyab ak kalite yo
Varyab sistèm
Dimansyon
Varyab anviwònman (anviwònman)
Operatè aritmetik ak konparezon
Operatè plasman yo
Operatè lojik
Kondisyonèl Ale
Sik
Ranje
Hash tab
Fonksyon
Pwosesis erè

Ou ka ekri kòd nan nenpòt editè tèks oswa lè l sèvi avèk yon anviwònman devlopman entegre - fason ki pi fasil se pran Windows PowerShell ISE ki vini ak sistèm opere sèvè Microsoft. Sa a se sèlman nesesè pou scripts jistis konplèks: seri kout kòmand yo pi fasil pou egzekite entèaktif.

Kòmantè

Sèvi ak kòmantè yo konsidere kòm yon pati nan bon style pwogramasyon ansanm ak endentasyon apwopriye ak espas blan:

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

<# 

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

#>

Varyab ak kalite yo

Varyab nan PowerShell yo rele objè yo. Non yo ka gen ladan karaktè souliye a, ansanm ak lèt ​​ak nimewo. Se $ senbòl la toujou itilize anvan non an, epi pou deklare yon varyab, li ase pou bay entèprèt la yon non valab:

Pou inisyalize yon varyab (bay yon valè a), yo itilize operatè plasman an (senbòl =):

$test = 100

Ou ka deklare yon varyab lè w espesifye kalite li nan parantèz kare (kalite operatè casting) anvan non an oswa valè:

[int]$test = 100

$test = [int]100

Li enpòtan pou w konprann ke varyab nan PowerShell yo se objè (klas) plen véritable ak pwopriyete ak metòd ki gen kalite yo baze sou sa yo ki nan .NET Nwayo. Nou lis prensipal yo:

Kalite (klas .NET)

Deskripsyon

Egzanp kòd

[string] System.String

fisèl Unicode 

$tès = "tès"
$tès = 'tès'

[char]System.Char

Unicode karaktè (16 bits)

[char]$test = 'c'

[bool] System.Boolean

Kalite booleyen (Booleyen Vre oswa Fo)

[bool]$tès = $vre

[int] System.Int32

trant-de bit nonb antye relatif (32 bit)

[int]$tès = 123456789

[long] System.Int64

swasant kat bit nonb antye relatif (64 bits)

[long]$tès = 12345678910

[sèl] System.Single

nimewo k ap flote 32 bit nan longè

[yon sèl]$tès = 12345.6789

[double]System.Double

kantite pwen k ap flote longè 64 bit (8 octets)

[double]$tès = 123456789.101112

[desimal]System.Decimal

Nimewo 128-bit k ap flote (obligatwa pou fini ak d)

[desimal]$tès = 12345.6789d

[DateTime]System.DateTime

dat ak lè 

$test = GetDate

[etalaj] System.Object[]

yon etalaj ki gen endèks eleman kòmanse nan 0

$test_array = 1, 2, "tès", 3, 4

[hashtable] System.Collections.Hashtable

Tablo hash yo se ranje asosyasyon ak kle yo nonmen, ki bati dapre prensip la: @{kle = "valè"}

$test_hashtable = @{one="yon"; de = "de"; twa="twa"}

PowerShell sipòte konvèsyon kalite implicite, anplis, kalite yon varyab ka chanje sou vole (pou egzanp, lè l sèvi avèk yon operatè plasman), si li pa espesifye ak fòs - nan ka sa a, entèprèt la pral bay yon erè. Ou ka detèmine ki kalite varyab la nan egzanp anvan an lè w rele metòd GetType() la:

$test.GetType().FullName

Gen yon kantite cmdlets pou manipile varyab yo. Lis yo nan yon fòm pratik parèt lè l sèvi avèk kòmandman an:

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

Pou wè varyab yo deklare ak valè yo, ou ka itilize yon cmdlet espesyal:

Get-Variable | more

Metòd sa a sanble twò ankonbran, li pi bon pou travay ak varyab atravè operatè yo oswa lè w jwenn aksè nan pwopriyete yo ak metòd yo dirèkteman. Sepandan, cmdlets yo gen dwa egziste paske yo pèmèt ou mete kèk paramèt adisyonèl. Li enpòtan pou w konprann ke varyab itilizatè yo defini sèlman nan sesyon aktyèl la. Lè konsole a fèmen oswa script la fini, yo efase.

Varyab sistèm

Anplis sa yo te deklare pa itilizatè a, gen bati-an (sistèm) varyab ki pa efase apre sesyon aktyèl la fini. Yo divize an de kalite, pandan y ap done eta PowerShell yo estoke nan varyab otomatik ki pa ka bay valè abitrè poukont yo. Men sa yo enkli, pa egzanp, $PWD:

$PWD.Path

Varyab preferans yo bezwen pou estoke preferans itilizatè yo, valè yo ka chanje. Pou egzanp, lè l sèvi avèk $ErrorActionPreference , reyaksyon entèprèt kòmand la nan ensidan an nan erè ki pa fatal.

Anplis operatè ak cmdlets pou jwenn aksè nan varyab deklare, gen yon Varyab: pseudo-accumulator. Ou ka travay avèk li pa analoji ak lòt kondui, ak varyab yo nan ka sa a sanble ak objè sistèm dosye:

Get-ChildItem Variable: | more

oswa

ls Variable: | more

Dimansyon

Pou varyab nan PowerShell, gen konsèp nan dimansyon (Scope). Aksyon nan dimansyon mondyal la (Global) aplike nan tout sesyon aktyèl la - li gen ladan, pou egzanp, varyab sistèm. Varyab lokal (lokal) yo disponib sèlman nan sijè ki abòde lan kote yo te defini: di andedan yon fonksyon. Genyen tou konsèp nan sijè ki abòde lan script (Script), men pou kòmandman script, li esansyèlman lokal. Pa default, lè yo deklare varyab yo, yo ba yo yon dimansyon lokal, epi chanje sa a, ou bezwen yon konstriksyon espesyal tankou: $Global: varyab = valè.

Pou egzanp, tankou sa a:

$Global:test = 100

Varyab anviwònman (anviwònman)

Yon lòt pseudo-kondwi, Env:, ki disponib nan PowerShell epi yo ka itilize pou jwenn aksè nan varyab anviwònman an. Lè koki a kòmanse, yo kopye soti nan pwosesis paran an (ki se, nan pwogram nan ki inisye sesyon aktyèl la) epi anjeneral valè inisyal yo se menm jan ak valè yo nan panèl la kontwòl. Pou wè varyab anviwònman an, sèvi ak cmdlet Get-ChildItem oswa alyas li yo (alyas): ls ak dir.

dir Env:

Varyab sa yo se sekans byte (oswa karaktè, si ou renmen), entèpretasyon an ki depann sèlman sou pwogram nan lè l sèvi avèk yo. *-Variable cmdlets yo pa travay ak varyab anviwònman yo. Pou jwenn aksè nan yo, ou dwe itilize prefiks kondwi a:

$env:TEST = "Hello, World!"

Operatè aritmetik ak konparezon

PowerShell bay operatè aritmetik sa yo: + (adisyon), - (soustraksyon), * (miltipliye), / (divizyon), ak % (modulo oswa modulo). Yo evalye rezilta yon ekspresyon aritmetik de goch a dwat dapre lòd operasyon yo jeneralman aksepte, epi yo itilize parantèz pou gwoupe pati ekspresyon an. Yo inyore espas ant operatè yo, yo itilize yo sèlman pou fè li pi fasil. Operatè a + konkaten tou, epi operatè a * repete kòd. Si ou eseye ajoute yon nimewo nan yon fisèl, li pral konvèti nan yon fisèl. Anplis de sa, lang PowerShell la gen anpil operatè konparezon ki tcheke pou yon match ant de valè epi retounen boolean Vre oswa Fo:

Operatè

Deskripsyon

Egzanp kòd

-ek

Egal / Egal (menm jan ak = oswa == nan lòt lang)

$tès = 100
$tès -eq 123 

- se

Pa egal / Pa egal (menm jan ak <> oswa !=)

$tès = 100
$test -ne 123   

-gt

Pi gran pase / Plis (analòg >)

$tès = 100
$test -gt 123

-ge

Pi gran pase oswa egal / Pi gwo pase oswa egal (menm jan ak >=)

$tès = 100
$test -ge 123

-lt

Mwens pase / Mwens (menm jan ak <)

$tès = 100
$test -lt 123  

-la

Mwens pase oswa egal / Mwens pase oswa egal (menm jan ak <=)

$tès = 100
$test -le 123

Gen lòt operatè menm jan an ki pèmèt ou, pou egzanp, konpare fisèl ki baze sou yon wildcard oswa itilize ekspresyon regilye yo matche ak yon modèl. Nou pral kouvri yo an detay nan atik nan lavni. Senbòl <, > ak = yo pa itilize pou konparezon paske yo itilize yo pou lòt rezon.

Operatè plasman yo

Anplis de operatè a ki pi komen =, gen lòt operatè plasman: +=, -=, *=, /= ak %=. Yo chanje valè a anvan plasman. Operatè inè ++ ak -, ki ogmante oswa diminye valè yon varyab, konpòte yo menm jan an - yo aplike tou pou operatè plasman yo.

Operatè lojik

Konparezon pou kont li pa ase pou dekri kondisyon konplèks. Ou ka ekri nenpòt ekspresyon lojik lè l sèvi avèk operatè yo: -and, -or, -xor, -not and! .. Yo travay tankou nan lòt langaj pwogramasyon, pandan w ap itilize parantèz pou presize lòd evalyasyon an:

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

-not (123 -gt 321) 

!(123 -gt 321)

Kondisyonèl Ale

Operatè Branch yo nan PowerShell yo estanda: IF(IF...ELSE, IF...ELSEIF...ELSE) ak SWITCH. Ann gade itilizasyon yo ak egzanp:

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

Sik

PowerShell gen plizyè varyete bouk: WHILE, DO WHILE, DO UNTIL, FOR, ak FOREACH.

Yon bouk ak yon prekondisyon ap travay si / osi lontan ke li se vre:

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

Loops ak yon postcondition pral kouri omwen yon fwa, paske kondisyon an tcheke apre iterasyon an. Anmenmtan, DO UNTIL ap travay pandan kondisyon an se vre, epi DO UNTIL ap travay pandan li fo:

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

Kantite iterasyon bouk FOR yo konnen davans:

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

Nan bouk FOREACH la, iterasyon sou eleman yo nan yon etalaj oswa koleksyon (tablo hash):

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

Ranje

Varyab PowerShell estoke pa sèlman yon sèl objè (nimewo, fisèl, elatriye), men tou plizyè bagay. Kalite ki pi senp nan varyab sa yo se etalaj. Yon etalaj ka konpoze de plizyè eleman, yon sèl eleman, oswa dwe vid, i.e. pa gen okenn eleman. Li te deklare lè l sèvi avèk @() operatè a, ke nou pral bezwen nan pwochen atik la - li trè enpòtan pou ajoute lòt etalaj nan yon etalaj (kreye etalaj miltidimansyonèl), pase etalaj nan fonksyon kòm yon agiman, ak travay menm jan an:

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

Lè yon etalaj inisyalize, valè li yo ki nan lis separe pa vigil (operatè espesyal ,):

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

Nan pifò ka yo, @() operatè a ka omisyon:

$test_array = 1, 2, 3, 4

Nan ka sa a, yon etalaj yon sèl eleman inisyalize jan sa a

$test_array = , 1

Yo jwenn aksè nan eleman etalaj yo lè l sèvi avèk yon endèks nonb antye ki baze sou zewo ak operatè endèks la (parantèz kare):

$test_array[0] = 1

Ou ka presize plizyè endèks separe pa vigil, enkli. renouvlab:

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

Operatè .. (de pwen - operatè ranje) retounen yon etalaj nonm antye ki nan limit anwo ak pi ba yo espesifye. Pa egzanp, ekspresyon 1..4 bay yon etalaj kat eleman @(1, 2, 3, 4), ak ekspresyon 8..5 bay yon etalaj @(8, 7, 6, 5).

Sèvi ak operatè ranje a, ou ka inisyalize yon etalaj ($test_array = 1..4) oswa jwenn yon tranch (tranch), i.e. yon sekans eleman ki soti nan yon etalaj ak endis ki soti nan yon lòt. Nan ka sa a, yon nimewo negatif -1 vle di dènye eleman nan etalaj la, -2 - youn nan penultyèm, ak sou sa.

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

Remake byen ke valè nonb antye relatif yo ka pi gran pase valè maksimòm endèks etalaj done yo. Nan ka sa a, tout valè yo retounen jiska dènye a:

$test_array[0..100]

Si ou eseye jwenn aksè nan yon sèl eleman etalaj ki pa-inexistant, $null yo retounen.

Nan PowerShell, etalaj yo ka genyen eleman diferan oswa yo ka tape byen:

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

Kote $test_array.count pwopriyete a se kantite eleman etalaj la.

Yon egzanp pou kreye yon etalaj fòtman tape:

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

Hash tab

Yon lòt kalite debaz varyab nan PowerShell se tab hash, ke yo rele tou etalaj asosyasyon. Hashtables yo sanble ak objè JSON epi yo bati sou yon baz kle-valè. Kontrèman ak etalaj òdinè, yo jwenn aksè nan eleman yo pa kle yo nonmen, ki se pwopriyete objè a (ou ka tou itilize operatè a endèks - parantèz kare).

Yo deklare yon tablo hash vid lè l sèvi avèk senbòl @ ak parantèz operatè yo:

$test_hashtable = @{}

Lè w deklare, ou ka imedyatman kreye kle epi bay yo valè:

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

Pou ajoute yon eleman nan yon tab hash, ou dwe bay yon kle ki poko egziste nan li, oswa itilize metòd Add (). Si yo fè yon plasman nan yon kle ki deja egziste, valè li a ap chanje. Metòd Remove() yo itilize pou retire yon eleman nan yon tab hash.

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

Varyab nan kalite sa a ka pase kòm agiman nan fonksyon ak cmdlets - nan pwochen atik la nou pral etidye ki jan sa a se fè, epi tou konsidere yon lòt kalite menm jan an - PSCustomObject.

Fonksyon

PowerShell gen tout sa ou bezwen pou pwogramasyon pwosedi, ki gen ladan fonksyon. Pou dekri yo, yo itilize mo fonksyon Fonksyon an, apre sa ou bezwen presize non fonksyon an ak kò a ki fèmen nan parantèz operatè yo. Si ou bezwen pase agiman nan fonksyon an, ou ka presize yo imedyatman apre non an nan parantèz.

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

Fonksyon an toujou retounen yon rezilta - li se yon etalaj de rezilta yo nan tout deklarasyon li yo, si gen plis pase youn. Si gen yon sèl deklarasyon, se sèlman valè ki koresponn lan retounen. Retounen $valè konstriksyon an ajoute yon eleman ki gen valè $valè nan etalaj rezilta a epi avòte egzekisyon lis deklarasyon an, epi fonksyon vid la retounen $null.

Pou egzanp, ann kreye yon fonksyon pou kare yon nonm:

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

Remake byen ke nan kò a nan yon fonksyon, ou ka itilize nenpòt varyab te deklare anvan ou rele li, epi rele fonksyon nan PowerShell ka sanble etranj: agiman yo (si genyen) yo pa fèmen nan parantèz epi yo separe pa espas.

sqr 2

oswa konsa:

sqr -number 2

Akòz fason agiman yo pase, fonksyon an tèt li pafwa bezwen mete nan parantèz:

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

Lè w ap dekri yon fonksyon, ou ka bay agiman valè default yo:

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

Gen yon lòt sentaks pou dekri agiman fonksyon, anplis de sa, paramèt yo ka li nan tiyo a - tout bagay sa yo ap vin an sou la men nan pwochen atik la, lè nou gade modil ekspòte ak kreye pwòp cmdlets nou yo.

Pwosesis erè

PowerShell gen yon Eseye...Trape...Finalman mekanis pou okipe eksepsyon yo. Blòk Try la gen kòd kote yon erè ka rive, epi blòk Catch la gen moun kap okipe li yo. Si pa te gen okenn erè, li pa egzekite. Blòk la Finally egzekite apre blòk Try la, kèlkeswa ensidan an nan yon erè, epi ka gen plizyè blòk Catch pou diferan kalite eksepsyon. Eksepsyon nan tèt li ekri nan yon varyab default ki pa deklare ($_) epi yo ka rekipere fasil. Nan egzanp ki anba a, nou aplike pwoteksyon kont antre yon valè ki pa valab:

try {

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

} catch {

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

}

Sa a konkli revizyon de baz yo nan pwogram nan lang PowerShell la. Nan atik sa yo, nou pral etidye an plis detay travay ak varyab diferan kalite, koleksyon, ekspresyon regilye, kreye fonksyon, modil ak cmdlets koutim, osi byen ke pwogram oryante objè.

Sous: www.habr.com