Ինչ է Windows PowerShell-ը և ինչով է այն ուտվում: Մաս 2. Ծրագրավորման լեզվի ներածություն

Պատմականորեն, Unix համակարգերում հրամանի տող կոմունալ ծառայություններն ավելի լավ են զարգացած, քան Windows-ում, սակայն նոր լուծման հայտնվելով իրավիճակը փոխվել է:

PowerShell-ը կարող է գրվել մեկնաբանված, բազմաբնույթ պարադիգմային լեզվով, որն ունի դասական ընթացակարգային, օբյեկտի վրա հիմնված և նույնիսկ ֆունկցիոնալ ծրագրավորման տարրեր՝ պայմանական ճյուղավորում, հանգույցներ, փոփոխականներ, զանգվածներ, հեշ աղյուսակներ, դասեր, սխալների մշակում, ինչպես նաև գործառույթներ, cmdlets և խողովակաշարեր: Նախորդ հոդվածը նվիրված էր շրջակա միջավայրում աշխատելու հիմունքներին, և այժմ մենք մեր ընթերցողներին առաջարկում ենք ծրագրավորողների համար նախատեսված փոքրիկ ուղեցույց:

Բովանդակություն:

Comments
Փոփոխականներ և դրանց տեսակները
Համակարգի փոփոխականներ
Շրջանակներ
Շրջակա միջավայրի փոփոխականներ (միջավայր)
Թվաբանական և համեմատական ​​օպերատորներ
Հանձնարարական օպերատորներ
Տրամաբանական օպերատորներ
Պայմանական թռիչք
Ցիկլեր
Զանգվածներ
Հեշ սեղաններ
Գործառույթներ
Սխալ մշակելիս

Դուք կարող եք կոդ գրել ցանկացած տեքստային խմբագրիչում կամ օգտագործելով մշակման ինտեգրված միջավայր. ամենահեշտ ձևը Windows PowerShell ISE-ն է, որը գալիս է Microsoft սերվերի օպերացիոն համակարգերով: Սա անհրաժեշտ է միայն բավականին բարդ սկրիպտների համար. հրամանների կարճ հավաքածուները ավելի հեշտ են ինտերակտիվ կերպով կատարել:

Comments

Մեկնաբանությունների օգտագործումը համարվում է լավ ծրագրավորման ոճի մաս, ինչպես նաև պատշաճ ներքև և բացատ.

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

<# 

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

#>

Փոփոխականներ և դրանց տեսակները

PowerShell-ի փոփոխականները կոչվում են օբյեկտներ: Նրանց անունները կարող են ներառել ընդգծված նիշ, ինչպես նաև տառեր և թվեր: $ նշանը միշտ օգտագործվում է անունից առաջ, և փոփոխական հայտարարելու համար բավական է թարգմանչին տալ վավեր անուն.

Փոփոխականը սկզբնավորելու համար (նրան արժեք նշանակելու համար) օգտագործվում է նշանակման օպերատորը (խորհրդանիշ =).

$test = 100

Դուք կարող եք փոփոխական հայտարարել՝ նշելով դրա տեսակը քառակուսի փակագծերում (տեսակ ձուլման օպերատոր) անունից կամ արժեքից առաջ.

[int]$test = 100

$test = [int]100

Կարևոր է հասկանալ, որ PowerShell-ի փոփոխականները լիարժեք օբյեկտներ (դասեր) են՝ հատկություններով և մեթոդներով, որոնց տեսակները հիմնված են .NET Core-ի վրա: Մենք թվարկում ենք հիմնականները.

Տեսակ (.NET դաս)

Նկարագրություն

Կոդի օրինակ

[string] System.String

Unicode տող 

$test = «փորձարկում»
$test = «փորձարկում»

[char]System.Char

Unicode նիշ (16 բիթ)

[char]$test = 'c'

[bool] System.Բուլյան

բուլյան տիպ (բուլյան ճշմարիտ կամ սխալ)

[bool]$test = $true

[int] System.Int32

երեսուներկու բիթ ամբողջ թիվ (32 բիթ)

[int]$test = 123456789

[երկար] System.Int64

վաթսունչորս բիթ ամբողջ թիվ (64 բիթ)

[երկար]$թեստ = 12345678910

[մեկ] System.Single

լողացող կետի թիվ 32 բիթ երկարությամբ

[մեկ]$թեստ = 12345.6789

[կրկնակի] System.Double

լողացող կետի երկարությունը 64 բիթ (8 բայթ)

[կրկնակի]$թեստ = 123456789.101112

[տասնորդական]Համակարգ։ Տասնորդական

128-բիթանոց լողացող կետի համարը (պահանջվում է ավարտվի d-ով)

[տասնորդական]$թեստ = 12345.6789d

[DateTime]System.DateTime

ամսաթիվը եւ ժամը 

$test = GetDate

[զանգված] System.Object[]

զանգված, որի տարրերի ինդեքսը սկսվում է 0-ից

$test_array = 1, 2, «փորձարկում», 3, 4

[hashtable] System.Collections.Hashtable

Հեշ աղյուսակները ասոցիատիվ զանգվածներ են անվանված ստեղներով, որոնք կառուցված են հետևյալ սկզբունքով՝ @{key = «արժեք»}

$test_hashtable = @{one="մեկ"; երկու = "երկու"; երեք = երեք"}

PowerShell-ն աջակցում է անուղղակի տիպի փոխակերպմանը, բացի այդ, փոփոխականի տեսակը կարող է փոփոխվել անմիջապես (օրինակ՝ հանձնարարականի օպերատորի միջոցով), եթե այն հարկադրաբար նշված չէ, այս դեպքում թարգմանիչը սխալ կտա: Դուք կարող եք որոշել փոփոխականի տեսակը նախորդ օրինակից՝ զանգահարելով GetType() մեթոդը՝

$test.GetType().FullName

Կան մի շարք cmdlets փոփոխականների մանիպուլյացիայի համար: Նրանց ցանկը հարմար ձևով ցուցադրվում է հրամանի միջոցով.

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

Հայտարարված փոփոխականները և դրանց արժեքները դիտելու համար կարող եք օգտագործել հատուկ cmdlet.

Get-Variable | more

Այս մեթոդը չափազանց դժվար է թվում, շատ ավելի հարմար է փոփոխականների հետ աշխատել օպերատորների միջոցով կամ ուղղակիորեն մուտք գործել դրանց հատկություններ և մեթոդներ: Այնուամենայնիվ, cmdlet-ները գոյություն ունենալու իրավունք ունեն, քանի որ դրանք թույլ են տալիս սահմանել որոշ լրացուցիչ պարամետրեր: Կարևոր է հասկանալ, որ օգտագործողի փոփոխականները սահմանվում են միայն ընթացիկ նստաշրջանում: Երբ վահանակը փակվում է կամ սցենարն ավարտվում է, դրանք ջնջվում են:

Համակարգի փոփոխականներ

Բացի օգտագործողի կողմից հայտարարվածներից, կան ներկառուցված (համակարգային) փոփոխականներ, որոնք չեն ջնջվում ընթացիկ նիստի ավարտից հետո: Նրանք բաժանված են երկու տեսակի, մինչդեռ PowerShell վիճակի տվյալները պահվում են ավտոմատ փոփոխականներում, որոնք չեն կարող ինքնուրույն նշանակվել կամայական արժեքներ: Դրանք ներառում են, օրինակ, $PWD:

$PWD.Path

Օգտատիրոջ նախասիրությունները պահելու համար անհրաժեշտ են նախապատվությունների փոփոխականներ, որոնց արժեքները կարող են փոխվել: Օրինակ, օգտագործելով $ErrorActionPreference-ը, սահմանվում է հրամանի թարգմանչի արձագանքը ոչ ճակատագրական սխալների առաջացմանը:

Բացի հայտարարագրված փոփոխականներին մուտք գործելու համար օպերատորներից և cmdlet-ներից, կա Փոփոխական՝ կեղծ կուտակիչ: Դուք կարող եք աշխատել դրա հետ անալոգիայով այլ կրիչներով, և փոփոխականներն այս դեպքում նման են ֆայլային համակարգի օբյեկտներին.

Get-ChildItem Variable: | more

կամ

ls Variable: | more

Շրջանակներ

PowerShell-ում փոփոխականների համար գոյություն ունի շրջանակի (Scope) հասկացությունը: Գլոբալ տիրույթի գործողությունը (Գլոբալ) վերաբերում է ողջ ընթացիկ նստաշրջանին, այն ներառում է, օրինակ, համակարգի փոփոխականներ: Տեղական (Տեղական) փոփոխականները հասանելի են միայն այն շրջանակում, որտեղ դրանք սահմանվել են՝ ասենք ֆունկցիայի ներսում: Գոյություն ունի նաև սկրիպտի շրջանակի հասկացությունը (Script), բայց սցենարի հրամանների համար այն ըստ էության տեղական է։ Լռելյայնորեն, փոփոխականներ հայտարարելիս նրանց տրվում է լոկալ շրջանակ, և դա փոխելու համար ձեզ անհրաժեշտ է հատուկ կառուցվածք, ինչպիսին է $Global: variable = value:

Օրինակ, այսպես.

$Global:test = 100

Շրջակա միջավայրի փոփոխականներ (միջավայր)

Մեկ այլ կեղծ դրայվ՝ Env:, հասանելի է PowerShell-ից և կարող է օգտագործվել շրջակա միջավայրի փոփոխականներ մուտք գործելու համար: Երբ կեղևը սկսվում է, դրանք պատճենվում են մայր գործընթացից (այսինքն, ծրագրից, որը նախաձեռնել է ընթացիկ նստաշրջանը) և սովորաբար դրանց սկզբնական արժեքները նույնն են, ինչ կառավարման վահանակի արժեքները: Շրջակա միջավայրի փոփոխականները դիտելու համար օգտագործեք Get-ChildItem cmdlet-ը կամ դրա փոխանունները (փոխանունները)՝ ls և dir:

dir Env:

Այս փոփոխականները բայթերի (կամ նիշերի, եթե ցանկանում եք) հաջորդականություն են, որոնց մեկնաբանությունը կախված է միայն դրանք օգտագործող ծրագրից։ *-Variable cmdlet-ները չեն աշխատում շրջակա միջավայրի փոփոխականների հետ: Դրանց մուտք գործելու համար դուք պետք է օգտագործեք սկավառակի նախածանցը.

$env:TEST = "Hello, World!"

Թվաբանական և համեմատական ​​օպերատորներ

PowerShell-ը տրամադրում է հետևյալ թվաբանական օպերատորները՝ + (գումարում), - (հանում), * (բազմապատկել), / (բաժանում) և % (մոդուլ կամ մոդուլ): Թվաբանական արտահայտության արդյունքը գնահատվում է ձախից աջ՝ գործողությունների ընդհանուր ընդունված կարգի համաձայն, և փակագծերը օգտագործվում են արտահայտության մասերը խմբավորելու համար։ Օպերատորների միջև տարածությունները անտեսվում են, դրանք օգտագործվում են միայն կարդալը հեշտացնելու համար: + օպերատորը նույնպես միանում է, իսկ * օպերատորը կրկնում է տողեր։ Եթե ​​փորձեք թիվ ավելացնել տողի վրա, այն կվերածվի տողի: Բացի այդ, PowerShell լեզուն ունի բազմաթիվ համեմատական ​​օպերատորներ, որոնք ստուգում են երկու արժեքների համընկնում և վերադարձնում բուլյան True կամ False:

Օպերատոր

Նկարագրություն

Կոդի օրինակ

-հավասար

Հավասար / Հավասար (նման է = կամ == այլ լեզուներով)

$test = 100
$test -eq 123 

-նե

Ոչ հավասար / Ոչ հավասար (նման <> կամ !=)

$test = 100
$test -ne 123   

-gt

Ավելի մեծ քան / ավելին (անալոգային >)

$test = 100
$test -gt 123

-գ

Ավելի մեծ կամ հավասար / Ավելի մեծ կամ հավասար (նման >=)

$test = 100
$test -ge 123

- լ

Ավելի քիչ, քան / պակաս (նման <)

$test = 100
$test -lt 123  

-լե

Պակաս կամ հավասար / Պակաս կամ հավասար (նման <=)

$test = 100
$test -le 123

Կան նմանատիպ այլ օպերատորներ, որոնք թույլ են տալիս, օրինակ, համեմատել տողերը՝ հիմնված նիշերի վրա կամ օգտագործել կանոնավոր արտահայտություններ՝ օրինաչափությանը համապատասխանելու համար: Մենք դրանք մանրամասն կանդրադառնանք հետագա հոդվածներում: <, > և = նշանները համեմատության համար չեն օգտագործվում, քանի որ դրանք օգտագործվում են այլ նպատակների համար:

Հանձնարարական օպերատորներ

Ի լրումն առավել տարածված = օպերատորի, կան նաև նշանակման այլ օպերատորներ՝ +=, -=, *=, /= և %=: Նրանք փոխում են արժեքը նախքան նշանակումը: ++ և - միանման օպերատորները, որոնք մեծացնում կամ նվազեցնում են փոփոխականի արժեքը, նույն կերպ են վարվում, դրանք կիրառվում են նաև հանձնարարական օպերատորների համար:

Տրամաբանական օպերատորներ

Միայն համեմատությունը բավարար չէ բարդ պայմանները նկարագրելու համար: Դուք կարող եք գրել ցանկացած տրամաբանական արտահայտություն՝ օգտագործելով օպերատորները.

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

-not (123 -gt 321) 

!(123 -gt 321)

Պայմանական թռիչք

PowerShell-ի մասնաճյուղերի օպերատորները ստանդարտ են՝ IF(IF…ELSE, IF…ELSEIF…ELSE) և SWITCH: Դիտարկենք դրանց օգտագործումը օրինակներով.

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

Ցիկլեր

PowerShell-ն ունի օղակների մի քանի տեսակներ՝ WHILE, DO WHILE, DO UNTIL, FOR և FOREACH:

Նախապայմանով հանգույցն աշխատում է, եթե/քանի դեռ դա ճշմարիտ է.

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

Հետպայմանով օղակները կաշխատեն առնվազն մեկ անգամ, քանի որ պայմանը ստուգվում է կրկնությունից հետո: Միևնույն ժամանակ, DO WHILE-ն աշխատում է, քանի դեռ պայմանը ճշմարիտ է, և DO WHILE-ն աշխատում է, մինչդեռ այն կեղծ է:

[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 օղակի կրկնությունների քանակը նախապես հայտնի է.

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

FOREACH հանգույցում կրկնվում է զանգվածի կամ հավաքածուի (հեշ աղյուսակ) տարրերի վրա.

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

Զանգվածներ

PowerShell փոփոխականները պահում են ոչ միայն առանձին օբյեկտներ (թիվ, տող և այլն), այլ նաև մի քանի օբյեկտներ: Նման փոփոխականների ամենապարզ տեսակը զանգվածներն են: Զանգվածը կարող է բաղկացած լինել մի քանի տարրերից, մեկ տարրից կամ դատարկ լինել, այսինքն. տարրեր չեն պարունակում: Այն հայտարարվում է @() օպերատորի միջոցով, որը մեզ պետք կգա հաջորդ հոդվածում. դա շատ կարևոր է զանգվածին այլ զանգվածներ ավելացնելու (բազմաչափ զանգվածներ ստեղծելու), զանգվածները ֆունկցիաներին որպես արգումենտ փոխանցելու և նմանատիպ առաջադրանքների համար.

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

Երբ զանգվածը սկզբնավորվում է, դրա արժեքները թվարկվում են՝ բաժանված ստորակետերով (հատուկ օպերատոր ,).

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

Շատ դեպքերում @() օպերատորը կարող է բաց թողնել.

$test_array = 1, 2, 3, 4

Այս դեպքում մեկ տարրի զանգվածը սկզբնավորվում է հետևյալ կերպ

$test_array = , 1

Զանգվածի տարրերը հասանելի են՝ օգտագործելով զրոյի վրա հիմնված ամբողջ թվի ինդեքսը և ինդեքսի օպերատորը (քառակուսի փակագծեր).

$test_array[0] = 1

Դուք կարող եք նշել մի քանի ինդեքսներ, որոնք բաժանված են ստորակետերով, ներառյալ. կրկնվող:

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

Օպերատոր .. (երկու կետ - տիրույթի օպերատոր) վերադարձնում է ամբողջ թվերի զանգված նշված վերին և ստորին սահմաններում: Օրինակ՝ 1..4 արտահայտությունը դուրս է բերում չորս տարրերից բաղկացած @(1, 2, 3, 4) զանգված, իսկ 8..5 արտահայտությունը՝ @(8, 7, 6, 5):

Օգտագործելով միջակայքի օպերատորը, կարող եք սկզբնավորել զանգված ($test_array = 1..4) կամ ստանալ շերտ (հատված), այսինքն. մի զանգվածից տարրերի հաջորդականություն մյուսի ինդեքսներով: Այս դեպքում բացասական -1 թիվը նշանակում է զանգվածի վերջին տարրը, -2-ը՝ նախավերջին և այլն։

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

Նկատի ունեցեք, որ ամբողջ թվային զանգվածի արժեքները կարող են ավելի մեծ լինել, քան տվյալների զանգվածի առավելագույն ինդեքսի արժեքը: Այս դեպքում բոլոր արժեքները վերադարձվում են մինչև վերջինը.

$test_array[0..100]

Եթե ​​փորձեք մուտք գործել զանգվածի մեկ գոյություն չունեցող տարր, $null-ը կվերադարձվի:

PowerShell-ում զանգվածները կարող են պարունակել տարբեր տեսակի տարրեր կամ խիստ տպագրված լինել.

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

Որտեղ $test_array.count հատկությունը զանգվածի տարրերի քանակն է:

Խիստ տպագրված զանգված ստեղծելու օրինակ.

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

Հեշ սեղաններ

PowerShell լեզվի փոփոխականների մեկ այլ հիմնական տեսակ են հեշ աղյուսակները, որոնք նաև հայտնի են որպես ասոցիատիվ զանգվածներ: Hashtable-ները նման են JSON օբյեկտներին և կառուցված են առանցքային արժեքի հիման վրա: Ի տարբերություն սովորական զանգվածների, դրանց տարրերը հասանելի են անվանված ստեղներով, որոնք օբյեկտի հատկություններ են (կարող եք նաև օգտագործել ինդեքսային օպերատորը՝ քառակուսի փակագծեր):

Դատարկ հեշ աղյուսակը հայտարարվում է @ խորհրդանիշի և օպերատորի փակագծերի միջոցով.

$test_hashtable = @{}

Հայտարարելիս կարող եք անմիջապես ստեղծել բանալիներ և դրանց արժեքներ վերագրել.

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

Հեշ աղյուսակում տարր ավելացնելու համար դուք պետք է նրան դեռևս գոյություն չունեցող բանալի վերագրեք կամ օգտագործեք Add () մեթոդը: Եթե ​​հանձնարարություն կատարվի գոյություն ունեցող բանալիին, դրա արժեքը կփոխվի: Remove() մեթոդը օգտագործվում է տարրը հեշ աղյուսակից հեռացնելու համար:

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

Այս տեսակի փոփոխականները կարող են փոխանցվել որպես արգումենտներ ֆունկցիաներին և cmdlet-ներին. հաջորդ հոդվածում մենք կուսումնասիրենք, թե ինչպես է դա արվում, ինչպես նաև կքննարկենք մեկ այլ նմանատիպ տեսակ՝ PSCustomObject:

Գործառույթներ

PowerShell-ն ունի այն ամենը, ինչ անհրաժեշտ է ընթացակարգային ծրագրավորման համար, ներառյալ գործառույթները: Դրանք նկարագրելու համար օգտագործվում է Function ֆունկցիայի բառը, որից հետո անհրաժեշտ է նշել ֆունկցիայի անվանումը և օպերատորի փակագծերում փակցված մարմինը։ Եթե ​​Ձեզ անհրաժեշտ է արգումենտներ փոխանցել ֆունկցիային, կարող եք դրանք նշել փակագծերի անունից անմիջապես հետո:

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

Ֆունկցիան միշտ արդյունք է տալիս. դա իր բոլոր հայտարարությունների արդյունքների զանգվածն է, եթե դրանք մեկից ավելի են: Եթե ​​կա միայն մեկ հայտարարություն, ապա վերադարձվում է համապատասխան տեսակի միակ արժեքը: Return $value կոնստրուկցիան արդյունքի զանգվածին ավելացնում է $value արժեք ունեցող տարր և ընդհատում է հայտարարությունների ցանկի կատարումը, իսկ դատարկ ֆունկցիան վերադարձնում է $null:

Օրինակ՝ եկեք ստեղծենք թվի քառակուսու համար նախատեսված ֆունկցիա.

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

Նկատի ունեցեք, որ ֆունկցիայի մարմնում կարող եք օգտագործել ցանկացած փոփոխական, որը հայտարարվել է այն կանչելուց առաջ, և PowerShell-ում ֆունկցիաները կանչելը կարող է անսովոր թվալ. արգումենտները (եթե այդպիսիք կան) փակագծերում չեն փակվում և բաժանված են բացատներով:

sqr 2

կամ այսպես.

sqr -number 2

Փաստարկների փոխանցման ձևի պատճառով ֆունկցիան ինքնին երբեմն անհրաժեշտ է փակագծերի մեջ փակել.

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

Ֆունկցիան նկարագրելիս կարող եք արգումենտներին լռելյայն արժեքներ նշանակել.

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

Գործառույթների փաստարկները նկարագրելու համար կա ևս մեկ շարահյուսություն, բացի այդ, պարամետրերը կարելի է կարդալ խողովակաշարից. այս ամենը օգտակար կլինի հաջորդ հոդվածում, երբ մենք նայենք արտահանված մոդուլներին և ստեղծենք մեր սեփական cmdlet-ները:

Սխալ մշակելիս

PowerShell-ն ունի «Փորձիր... բռնել...» վերջապես բացառությունները կարգավորելու մեխանիզմ: Փորձել բլոկը պարունակում է կոդը, որում կարող է առաջանալ սխալ, իսկ Catch բլոկը պարունակում է իր մշակողը: Եթե ​​սխալ չի եղել, այն չի կատարվում։ Վերջնական բլոկը կատարվում է Try բլոկից հետո՝ անկախ սխալի առաջացումից, և կարող են լինել մի քանի Catch բլոկներ տարբեր տեսակի բացառությունների համար։ Բացառությունն ինքնին գրված է չհայտարարված լռելյայն փոփոխականի վրա ($_) և կարող է հեշտությամբ վերականգնվել: Ստորև բերված օրինակում մենք իրականացնում ենք պաշտպանություն անվավեր արժեք մուտքագրելուց.

try {

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

} catch {

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

}

Սա ավարտում է PowerShell լեզվով ծրագրավորման հիմունքների վերանայումը: Հետագա հոդվածներում մենք ավելի մանրամասն կուսումնասիրենք տարբեր տեսակի փոփոխականների, հավաքածուների, կանոնավոր արտահայտությունների հետ աշխատելը, ֆունկցիաների, մոդուլների և հատուկ cmdlet-ների ստեղծումը, ինչպես նաև օբյեկտի վրա հիմնված ծրագրավորումը:

Source: www.habr.com