Какво е 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

тридесет и два разрядно цяло число (32 бита)

[int]$test = 123456789

[long]
System.Int64

шестидесет и четири разрядно цяло число (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

дата и час 

$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

Има определено количество команди за управление на променливите. Списъкът им в удобен формат се извежда с команда:

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

За преглед на обявените променливи и техните стойности може да се използва специална команда:

Get-Variable | more

Този подход изглежда прекалено тромав, с променливите е много по-удобно да се работи чрез оператори или да се обръщате към техните свойства и методи директно. Въпреки това, командите имат правото на съществуване, тъй като позволяват задаване на допълнителни параметри. Важно е да се разбере, че потребителските променливи са дефинирани само в рамките на текущата сесия. След затваряне на конзолата или завършване на скрипта, те се изтриват.

Системни променливи

Освен обявените от потребителя, съществуват и вградени (системни) променливи, които не се изтриват след приключване на текущата сесия. Те се делят на два типа, като информацията за състоянието на PowerShell се съхранява в автоматични променливи, на които не може да се присвоят произволни стойности. Към тях принадлежи, например, $PWD:

$PWD.Path

За съхранение на потребителски настройки са нужни променливи на предпочитания, чиито стойности могат да се променят. Например, с помощта на $ErrorActionPreference се задава реакцията на интерпретатора на команди при възникване на некритични грешки.

В допълнение към операторите и командлетите за достъп до обявените променливи съществува псевдонакопител Variable:. Може да се работи с него по аналогия с други накопители, а променливите в този случай наподобяват обекти от файловата система:

Get-ChildItem Variable: | more

или

ls Variable: | more

Области на видимост

За променливите в PowerShell съществува понятието област на видимост (Scope). Действието на глобалната област (Global) обхваща целия текущ сесионен период — в нея влизат, например, системните променливи. Локалните (Local) променливи са достъпни само в областта, където са дефинирани: да кажем, в рамките на функция. Има още понятие за област на действие на сценария (Script), но за командите на сценария, тя по същество е локална. По подразбиране, при обявяване на променливи им се задава локална област на действие, а за да я промените, е нужна специална конструкция от вида: $Global: променлива = стойност.

Например, така:

$Global:test = 100

Променливи на средата

От PowerShell е достъпен още един псевдонакопител Env:, чрез който може да се получи достъп до променливите на средата. При стартиране на оболката, те се копират от родителския процес (т.е. от програмата, инициираща текущата сесия) и обикновено тяхната първоначална стойност съвпада с тези в контролния панел. За преглед на променливите на средата се използва командлет Get-ChildItem или неговите псевдоними (алиаси): ls и dir.

dir Env:

Тези променливи представляват последователности от байтове (или символи, ако щете), чиято интерпретация зависи само от програмата, която ги използва. Командлетите *-Variable с променливите на средата не работят. За да получите достъп до тях, ще трябва да използвате префикса на диска:

$env:TEST = "Hello, World!"

Аритметични оператори и оператори за сравнение

В PowerShell има следните аритметични оператори: + (събиране), — (изваждане), * (умножение), / (деление) и % (остатък от делението). Резултатът от аритметичното изразяване се изчислява отляво надясно в съответствие с общоприетия ред на операциите, а за групиране на части от израза се използват кръгли скоби. Пробелите между операторите се игнорират, те се използват само за улесняване на възприятието. Операторът + също така обединява, а операторът * повтаря низове. При опит за събиране на число с низ, то ще бъде преобразувано в низ. Освен това, в PowerShell има множество оператори за сравнение, които проверяват съответствието между две стойности и връщат логически True или False:

Оператор

Описание

Примерен код

-eq

Равно / Равно (аналог на = или == в други езици)

$test = 100
$test -eq 123 

-ne

Не равно / Не равно (аналог или !=)

$test = 100
$test -ne 123   

-gt

По-голямо / По-голямо (аналог на >)

$test = 100
$test -gt 123

-ge

По-голямо или равно / По-голямо или равно (аналог на >=)

$test = 100
$test -ge 123

-lt

По-малко / По-малко (аналог на <)

$test = 100
$test -lt 123  

-le

По-малко или равно / По-малко или равно (аналог на <=)

$test = 100
$test -le 123

Съществуват и други подобни оператори, позволяващи например сравняване на низове с оглед на символа подмяна или използване на регулярни изрази за търсене на съответствие с шаблон. Тях ще разгледаме подробно в следващите статии. Символите и = за сравнение не се използват, тъй като са заети за други цели.

Оператори за присвояване

Освен най-разпространения оператор =, съществуват и други оператори за присвояване: +=, -=, *=, /= и %=, които променят стойността преди присвояването. Подобно поведение имат и унарните оператори ++ и —, които увеличават или намаляват стойността на променливата – те също са част от операторите за присвояване.

Логически оператори

За описването на сложни условия единствено сравнението не е достатъчно. Всички логически изрази могат да бъдат записани с помощта на операторите: -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 "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  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) или да се получи срез (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 — хеш-таблици, които също наричат асоциативни масиви. Хеш-таблиците приличат на 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 ($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) {
         #тяло на функцията
}

Съществува и друг синтаксис за описание на аргументите на функцията, освен това параметрите могат да се прочитат от конвейера — всичко това ще ни бъде полезно в следващата статия, когато ще разглеждаме експортирани модули и създаване на собствени командлети.

Обработка на грешки

В PowerShell съществува механизъм Try…Catch…Finally, който позволява обработката на изключителни ситуации. В блока Try се поставя кодът, в който може да възникне грешка, а в блока Catch — нейният обработчик. Ако грешка не е възникнала, той не се изпълнява. Блокът Finally се изпълнява след блока Try независимо от възникването на грешка, а блоковете Catch могат да бъдат няколко за изключения от различни типове. Самото изключение се записва в променлива, която не изисква обявяване по подразбиране ($_) и може да бъде лесно извлечена. В примера по-долу реализираме защита от въвеждане на неправилна стойност:

try {

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

} catch {

         Write-Warning "Неправилно число"
         Write-Host $_

}

На това разглеждането на основите на програмирането на езика PowerShell трябва да приключи. В следващите статии ще проучим по-подробно работата с променливи от различни типове, колекции, регулярни изрази, създаване на функции, модули и собствени команди, както и обектно-ориентираното програмиране.

Източник: habr.com