🥇Ինչ է Windows PowerShell-ը և ինչի համար է այն կամ սպառում: Բաժին 2: ծրագրավորման լեզվի մուտք

Պատմականորեն հրամանային տողերի գործիքը Unix համակարգերում ավելի լավ զարգացել է, քան Windows-ում, սակայն նոր լուծման появлением իրավիճակը փոխվել է:

PowerShell համար կարելի է գրել սցենարներ интерпретируемом բազմապատկերային լեզվում, որտեղ կան դասական ընթացիկ, օբյեկտային և նույնիսկ ֆունկցիոնալ ծրագրավորման տարրեր. պայմանական անցում, շրջաններ, փոփոխականներ, զանգվածներ, հաշտ-թաբլեր, դասեր, սխալների բուժում, ինչպես նաև ֆունկցիաներ, կոմանդլետներ և խողովակներ: Նախորդ հոդվածն իրավիճակը նվիրված էր միջավայրում աշխատանքի հիմքերին, իսկ հիմա մենք առաջարկում ենք ընտրողներին մի փոքր ձեռնարկ программистов:

Ժամանակացույցը:

Մեկնաբանություններ
Մոդուլներ և դրանց տեսակներ
Սիստեմային մոդուլները
Ոտերին տեսարաններ
Մոդուլային միջավայրեր
Արիմետիկ օպերատորներ և համեմատական օպերատորներ
Հանձնարարական օպերատորներ
Լոգիկական օպերատորներ
Պայմանական անցումը
Շրջանակներ
Մասիվներ
Հաշտ-թաբլեր
Ֆունկցիաներ
Սխալների բուժումը

Գրեք կոդը կարելի է ցանկացած տեքստային խմբագրիչում կամ օգտագործելով ինտեգրված զարգացնող միջավայր — ավելի հեշտ է վերցնել Windows PowerShell ISE Microsoft-ի серверային օպերացիոն համակարգերի կոմպլեկտից: Սա պահանջվում է միայն բավականին բարդ սցենարների համար: Կարճ հրամանների հավաքածուները ավելի հեշտ է գործարկել ինտերակտիվ ռեժիմով:

Մեկնաբանություններ

Մեկնաբանությունների օգտագործումն считается частю хорошего стиля программирования наряду с правильными отступами и пробелами:

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

<# 

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

#>

Մոդուլներ և դրանց տեսակներ

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.Boolean

բուլյան տիպ (логическое значение True կամ False)

[bool]$test = $true

[int]
System.Int32

երեսուներկուbit целое число (32 բիթ)

[int]$test = 123456789

[long]
System.Int64

քսաներկուbit целое число (64 բիթ)

[long]$test = 12345678910

[single]
System.Single

զարատունլգի թվերը 32 բիթի համար

[single]$test = 12345.6789

[double]
System.Double

արկածային թվեր 64 բիթի (8 բիթ)

[double]$test = 123456789.101112

[decimal]
System.Decimal

արկածային թվերը 128 բիթով (պետք է նշել d՝ վերջում)

[decimal]$test = 12345.6789d

[DateTime]
System.DateTime

tarikh ve vaxt

$test = Get-Date

[array]
System.Object[]

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

$test_array = 1, 2, «թեստ», 3, 4

[hashtable]
System.Collections.Hashtable

հաշվողական աղյուսակները` անվանված բանալիներով կառուցված ասոցիատիվ մասիվներ են, կառուցված սկզբունքով: @{բանալին = «արժեք»}

$test_hashtable = @{one=«մեկ»; two=«երկու»; three=«երեք»}

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

$test.GetType().FullName

PostFix տեղային փոփոխականների կառավարման համար որոշակի կեցվածքներ կան: Դրանց ցանկը հարմար ձևով տրվում է հետևյալ հրամանի միջոցով:

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

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

Get-Variable | more

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

Սիստեմային մոդուլները

Բացի օգտվողի կողմից հայտարարված փոփոխականներից, կան նաև встроенных (համակարգային) փոփոխականներ, որոնք չհեռացվում են ընթացիկ seans-ի ավարտից հետո: Դրանք բաժանվում են երկու տեսակի, մինչդեռ PowerShell-ի վիճակի տվյալները պահվում են ավտոմատ փոփոխականներում, որոնք հնարավոր չէ ինքնուրույն նշանակել պատահական արժեքներ: Դրանցից օրինակ է $PWD:

$PWD.Path

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

Ավելին օպերատորների և կեցվածքների մասին, որոնք նախատեսում են հռչակված փոփոխականներին, կա նաև псевдонаկուտիչ Variable:. Այնտեղ աշխատելը կարելի է անել մյուս կեցվածքներին նմանությամբ, իսկ փոփոխականները այս դեպքում նման են ֆայլային համակարգի օբյեկտներին:

Get-ChildItem Variable: | more

կամ

ls Variable: | more

Ոտերին տեսարաններ

PowerShell-ում փոփոխականների համար գոյություն ունի տեսադաշտի (Scope) հասկացություն։ Գլոբալ տեսադաշտի (Global) գործողությունը տարածվում է ներկա seans-ի վրա՝ ներառելով, օրինակ, համակարգի փոփոխականները։ Լոկալ (Local) փոփոխականները հասանելի են միայն այն տեսադաշտում, որտեղ դրանք սահմանված են, ասենք՝ ֆունկցիայի ներսում։ Կան նաև սկրիպտի տեսադաշտի (Script) հասկացություն, բայց հրահանգների համար այն պատշաճապես դառնում է lokoal։ Միայն մուտքագրելիս փոփոխականները ըստ էության ստանում են lokoal տեսադաշտ, իսկ դա փոխելու համար անհրաժեշտ է հատուկ կառուցվածք՝ տեսքով։ $Global: փոփոխական = արժեք:

Օրինակ՝ այնպես:

$Global:test = 100

Մոդուլային միջավայրեր

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

dir Env:

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

$env:TEST = "Hello, World!"

Արիմետիկ օպերատորներ և համեմատական օպերատորներ

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

Օպերատոր

Նկարագիր

Կոդի օրինակ

-eq

Համապատասխանել / Equal (այլ լեզուներում = կամ == համարժեք)

$test = 100
$test -eq 123

-ne

Չհամապատասխանել / Not equal (այլ լեզուներում կամ !=)

$test = 100
$test -ne 123

-gt

Ուրախ անցնել / Greater than (այլ լեզուներում > համարժեք)

$test = 100
$test -gt 123

-ge

Ուրախ անցնել կամ հավասար / Greater than or equal (այլ լեզուներում >= համարժեք)

$test = 100
$test -ge 123

-lt

Քիչ / Less than (այլ լեզվում < համարժեք)

$test = 100
$test -lt 123

-le

Քիչ կամ հավասար / Less than or equal (այլ լեզվում <= համարժեք)

$test = 100
$test -le 123

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

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

Բացի ամենատարածված օպերատորից՝ '=' առկա են նաև այլ վերապահման օպերատորներ՝ '+=', '-=', '*=', '/=' և '%='. Նրանք փոխում են արժեքը վերապահումից առաջ։ Նմանապես վարվում են միանման օպերատորները՝ '++' և '--', որոնք ավելացնում կամ նվազեցնում են փոփոխականի արժեքը՝ նրանք ևս վերապահման օպերատորների շարքում են։

Լոգիկական օպերատորներ

Complex իրավիճակների նկարագրության համար միայն համեմատությունը անբավարար է։ Աճելու ցանկացած տրամաբանական արտահայտությունը կարելի է գրել ՝ օգտագործելով օպերատորներ՝ -and, -or, -xor, -not և!.. Նրանք աշխատում են ինչպես մյուս ծրագրավորման լեզուներում, և կարելի է օգտագործել փակագծեր՝ հաշվարկի հերթականությունը սահմանելու համար։

("Թեստ" -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 "թեստ = 100"
}



[int]$test = 50
if ($test -eq 100) {
       Write-Host "թեստ = 100"
}
else {
      Write-Host "թեստ  100"
}



[int]$test = 10
if ($test -eq 100) {
      Write-Host "թեստ = 100"
}
elseif ($test -gt 100) {
      Write-Host "թեստ > 100"
}
else {
       Write-Host "թեստ  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 UNTIL-ը՝ երբ այն կեղծ է։

[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) կամ ձեռք բերել տSlices (slice), այլ կերպ ասած, մեկ զանգվածի տարրերի հաջորդականություն մյուսի ինդեքսներով: Որոշ դեպքերում բացասական թիվ -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")

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

Ֆունկցիաներ

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

function անուն-ֆունկցիայի (պաստարկ1, ..., պաստարկN) 
{ 
        ֆունկցիայի-մարմինը 
}

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

Օրինակ, ստեղծենք թիվը քառակուսի վեր համարկելու ֆունկցիա:

function sqr ($թիվ)
{
      return $թիվ * $թիվ
}

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

sqr 2

կամ այսպես:

sqr -number 2

Փաստարկների փոխանցման եղանակի հետևանքով երբեմն ֆունկցիան պետք է փակագծերի մեջ դրվի:

function test_func ($n) {}
test_func -eq $null     # ֆունկցիան չի կոչվել
(test_func) -eq $null   # արտահայտության արդյունքը՝ $true

Ֆունկցիա նկարագրելիս կարելի է նշանակել փաստարկներին լռելյայն արժեքներ:

function func ($arg = արժեք) {
         #ֆունկցիայի-մարմինը
}

Կան նաև այլ սինտաքսիսներ ֆունկցիայի փաստարկների նկարագրության համար, ավելին՝ պարամետրերը կարող են ընթանալ խողովակից՝ սա բոլորն օգտակար կլինի հաջորդ հոդվածում, երբ մենք կնայենք արտահանման մոդուլները և սեփական կոմանդլետների ստեղծումը:

Սխալների բուժումը

PowerShell-ում կա Try…Catch…Finally մեխանիզմ, որն օգնում է մշակել բացառություններով մետաաբանական իրավիճակներ: Try բլոկի մեջ տեղադրվում է այն կոդը, որտեղ կարող է առաջանալ սխալ, իսկ Catch բլոկում՝ դրա մշակողը: Եթե սխալ չկա, այն չի իրականացվում: Finally բլոկը կատարվում է Try բլոկից հետո՝ անկախ սխալի առաջացմանը, իսկ Catch բլոկները կարող են լինել մի քանիսը տարբեր տիպերի բացառությունների համար: Սեփական բացառությունը գրանցվում է հայտարարություն չպահանջող փոփոխականում ($_) և կարող է հեշտությամբ հանվել: Նվազիվ մենք իրականացնում ենք պաշտպանություն սխալ արժեքի մուտքի դեմ:

try {

        [int]$test = Read-Host "Մուտքագրեք число"
        100 / $test

} catch {

         Write-Warning "Սխալ թիվ"
         Write-Host $_

}

Այսպիսով, PowerShell ծրագրավորման հիմունքները քննարկելը կարող ենք ավարտել այստեղ։ Ի النجاح մյուս հոդվածներում ավելի մանրամասն ուսումնասիրելու ենք տարբեր տեսակի փոփոխականների զանգվածները, կանոնավոր արտահայտությունները, ֆունկցիաների, մոդուլների և սեփական կոմանդլետների ստեղծումը, ինչպես նաև օբյեկտ-համակարգչային ծրագրավորումը։