Какво е 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 — хеш-таблици, които също се наричат асоциативни масиви. 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("четири", "четири")
$test_hashtable.five = "пет"
$test_hashtable['five'] = "променяме стойността"
$test_hashtable.Remove("един")

Променливите от този тип могат да се предават като аргументи на функции и командлета - в следващата статия ще разгледаме как става това, а също така ще разгледаме и един подобен тип - 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