Какво е Windows PowerShell и с какво се яде? Част 2: Въведение в езика за програмиране

Исторически помощните програми за команден ред на Unix системи са по-добре развити, отколкото на Windows, но с появата на ново решение ситуацията се промени.

PowerShell може да бъде скриптиран на интерпретиран, многопарадигмен език, който има елементи на класическо процедурно, обектно-ориентирано и дори функционално програмиране: условно разклоняване, цикли, променливи, масиви, хеш-таблици, класове, обработка на грешки, както и функции, кратки команди и тръбопроводи. Предходная статия беше посветен на основите на работата в околната среда, а сега предлагаме на нашите читатели малък справочник за програмисти.

Съдържание:

Коментари
Променливи и техните видове
Системни променливи
Обхвати
Променливи на средата (среда)
Аритметични и сравнителни оператори
Оператори за присвояване
Логически оператори
Условен скок
цикли
масиви
Хеш таблици
функции
Грешка при работа

Можете да пишете код във всеки текстов редактор или да използвате интегрирана среда за разработка - най-лесният начин е да вземете Windows PowerShell ISE, който се доставя със сървърни операционни системи на Microsoft. Това е необходимо само за доста сложни скриптове: кратките набори от команди са по-лесни за интерактивно изпълнение.

Коментари

Използването на коментари се счита за част от добрия стил на програмиране заедно с правилния отстъп и интервал:

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

<# 

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

#>

Променливи и техните видове

Променливите в PowerShell са именувани обекти. Имената им могат да включват долната черта, както и букви и цифри. Символът $ винаги се използва преди името и за да декларирате променлива е достатъчно да дадете на интерпретатора валидно име:

За инициализиране на променлива (присвояване на стойност към нея) се използва операторът за присвояване (символ =):

$test = 100

Можете да декларирате променлива, като посочите нейния тип в квадратни скоби (оператор за преобразуване на типа) преди името или стойността:

[int]$test = 100

$test = [int]100

Важно е да се разбере, че променливите в PowerShell са пълноценни обекти (класове) със свойства и методи, чиито типове са базирани на тези в .NET Core. Изброяваме основните:

Тип (.NET клас)

описание

Примерен код

[низ] 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

[дълъг] System.Int64

шестдесет и четири бита цяло число (64 бита)

[дълъг]$test = 12345678910

[единичен] System.Single

число с плаваща запетая с дължина 32 бита

[единичен]$тест = 12345.6789

[double]System.Double

число с плаваща запетая с дължина 64 бита (8 байта)

[double]$test = 123456789.101112

[decimal]Система.Decimal

128-битово число с плаваща запетая (задължително да завършва с d)

[десетичен]$тест = 12345.6789d

[DateTime]System.DateTime

дата и час 

$test = GetDate

[масив] System.Object[]

масив, чийто индекс на елемент започва от 0

$test_array = 1, 2, "тест", 3, 4

[хеш таблица] System.Collections.Hashtable

хеш таблиците са асоциативни масиви с именувани ключове, изградени на принципа: @{key = "value"}

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

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

Get-ChildItem Variable: | more

или

ls Variable: | more

Обхвати

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

Например това:

$Global:test = 100

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

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

dir Env:

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

$env:TEST = "Hello, World!"

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

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

оператор

описание

Примерен код

-екв

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

$тест = 100
$test -eq 123 

-не

Не е равно / Не е равно (подобно на <> или !=)

$тест = 100
$test -ne 123   

-gt

По-голямо от / Повече (аналогов >)

$тест = 100
$test -gt 123

-ge

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

$тест = 100
$test -ge 123

- lt

По-малко от / По-малко (подобно на <)

$тест = 100
$test -lt 123  

-ле

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

$тест = 100
$test -le 123

Има други подобни оператори, които ви позволяват например да сравнявате низове въз основа на заместващ знак или да използвате регулярни изрази, за да съответствате на шаблон. Ще ги разгледаме подробно в следващите статии. Символите <, > и = не се използват за сравнение, защото се използват за други цели.

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

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

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

Самото сравнение не е достатъчно, за да се опишат сложни условия. Можете да напишете всякакви логически изрази, като използвате операторите: -and, -or, -xor, -not and! .. Те работят като в други езици за програмиране, докато можете да използвате скоби, за да посочите реда на оценка:

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

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