Istoric, utilitarele din linia de comandă în sistemele Unix s-au dezvoltat mai bine decât în Windows, însă odată cu apariția unei noi soluții, situația s-a schimbat.
Pentru PowerShell, se pot scrie scripturi într-un limbaj interpretat multiparadigmă, care include elemente de programare procedurală clasică, orientată pe obiecte și chiar funcțională: ramificări condiționale, bucle, variabile, matrice, tabele hash, clase, gestionarea erorilor, precum și funcții, cmdlet-uri și conducte. a fost dedicată fundamentelor lucrului în mediu, iar acum oferim lectorilor un mic ghid pentru programatori.
Cuprins:
Codul poate fi scris în orice editor de text sau folosind un mediu integrat de dezvoltare — cel mai simplu este să folosești Windows PowerShell ISE din pachetul sistemelor de operare server Microsoft. Acest lucru este necesar doar pentru scripturi destul de complexe: seturile scurte de comenzi sunt mai ușor de executat în modul interactiv.
Comentarii
Utilizarea comentariilor este considerată parte a unui stil bun de programare, alături de indentări și spații corecte:
# Для строчных комментариев используется символ решетки — содержимое строки интерпретатор не обрабатывает.
<#
Так обозначаются начало и конец блочного комментария.
Заключенный между ними текст интерпретатор игнорирует.
#>
Variabile și tipurile acestora
Variabilele în PowerShell sunt obiecte denumite. Numele lor pot include simboluri de subliniere, precum și litere și cifre. În fața numelui este întotdeauna folosit simbolul $, iar pentru a declara o variabilă, este suficient să specifici un nume valid pentru interpretator:
Pentru a inițializa o variabilă (a-i atribui o valoare), se folosește operatorul de atribuire (simbolul =):
$test = 100O variabilă poate fi declarată specificând tipul său în paranteze pătrate (operator de conversie de tip) înainte de nume sau valoare:
[int]$test = 100
$test = [int]100Este important de înțeles că variabilele în PowerShell sunt obiecte complete (clase) cu proprietăți și metode, a căror tipuri se bazează pe cele existente în .NET Core. Să enumerăm principalele:
Tip (clasă .NET)
Descriere
Exemplu de cod
[string]
System.String
șir Unicode
$test = «test»
$test = ‘test’
[char]
System.Char
simbol Unicode (16 biți)
[char]$test = ‘c’
[bool]
System.Boolean
tip boolean (valoare logică True sau False)
[bool]$test = $true
[int]
System.Int32
număr întreg de 32 de biți (32 biți)
[int]$test = 123456789
[long]
System.Int64
număr întreg de 64 de biți (64 biți)
[long]$test = 12345678910
[single]
System.Single
număr cu virgulă mobilă de 32 de biți
[single]$test = 12345.6789
[double]
System.Double
număr în virgulă mobilă de 64 biți (8 octeți)
[double]$test = 123456789.101112
[decimal]
System.Decimal
număr în virgulă mobilă de 128 biți (este obligatorie specificarea d la sfârșit)
[decimal]$test = 12345.6789d
[DateTime]
System.DateTime
dată și timp
$test = Get-Date
[array]
System.Object[]
masiv, indexul elementelor începe de la 0
$test_array = 1, 2, "test", 3, 4
[hashtable]
System.Collections.Hashtable
tabele hash - matrice asociative cu chei numite, construite după principiul: @{cheie = "valoare"}
$test_hashtable = @{one="unu"; two="doi"; three="trei"}
PowerShell suportă conversia implicită a tipurilor, de asemenea, tipul variabilei poate fi schimbat în timpul execuției (de exemplu, prin operatorul de atribuire), dacă nu este specificat cu forță - în acest caz, interpretul va genera o eroare. Tipul variabilei din exemplul anterior poate fi determinat prin apelarea metodei GetType():
$test.GetType().FullName 
Există un anumit număr de cmdlet-uri pentru gestionarea variabilelor. Lista lor este prezentată într-o formă convenabilă folosind comanda:
Get-Command -Noun Variable | ft -Property Name, Definition -AutoSize -Wrap 
Pentru a vizualiza variabilele declarate și valorile lor, se poate utiliza un cmdlet special:
Get-Variable | moreAceastă metodă pare excesiv de greoaie, lucrul cu variabilele este mult mai convenabil prin intermediul operatorilor sau accesând direct proprietățile și metodele acestora. Cu toate acestea, cmdlet-urile au dreptul la existență, deoarece permit stabilirea unor parametrii suplimentari. Este important să înțelegem că variabilele utilizatorului sunt definite doar în cadrul sesiunii curente. După închiderea consolei sau terminarea scriptului, acestea sunt șterse.
Variabile sistem
Pe lângă variabilele declarate de utilizator, există și variabile incorporate (sistemice) care nu sunt șterse după încheierea sesiunii curente. Ele se împart în două tipuri, iar datele de stare PowerShell sunt stocate în variabile automate cărora nu le poți atribui valori arbitrare. Printre acestea se numără, de exemplu, $PWD:
$PWD.Path 
Pentru a stoca setările utilizatorului sunt necesare variabile de preferințe, a căror valori pot fi modificate. De exemplu, prin $ErrorActionPreference se stabilește reacția interpretului de comenzi la apariția erorilor non-critice.
În plus față de operatorii și cmdlet-urile pentru accesarea variabilelor declarate, există un pseudo-depozit Variable:. Acesta poate fi utilizat similar cu celelalte depozite, iar variabilele, în acest caz, seamănă cu obiecte din sistemul de fișiere:
Get-ChildItem Variable: | moresau
ls Variable: | more 
Domeniile de vizibilitate
Pentru variabilele din PowerShell există conceptul de domeniu de vizibilitate (Scope). Acțiunea domeniului global (Global) se extinde pe întreaga sesiune curentă — acesta include, de exemplu, variabilele de sistem. Variabilele locale (Local) sunt disponibile doar în domeniul în care au fost definite: să zicem, în interiorul unei funcții. Există de asemenea conceptul de domeniu de acțiune al scriptului (Script), dar pentru comenzile scriptului este, de fapt, local. În mod implicit, la declararea variabilelor, acestea primesc un domeniu de acțiune local, iar pentru a schimba acest lucru, este nevoie de o structură specială de tipul: $Global: variabilă = valoare.
De exemplu, așa:
$Global:test = 100
Variabile de mediu
Din PowerShell, există un alt pseudo-depozit Env:, prin care se pot accesa variabilele de mediu. La pornirea shell-ului, acestea sunt copiate din procesul părinte (adică din programul care inițiază sesiunea curentă) și de obicei valorile lor inițiale coincid cu valorile din panoul de control. Pentru a vizualiza variabilele de mediu, se folosește cmdlet-ul Get-ChildItem sau aliasurile sale: ls și dir.
dir Env: 
Aceste variabile reprezintă secvențe de octeți (sau caractere, dacă preferați), interpretarea cărora depinde doar de programul care le utilizează. Cmdlet-urile *-Variable nu funcționează cu variabilele de mediu. Pentru a accesa aceste variabile, va trebui să folosiți prefixul de disc:
$env:TEST = "Hello, World!" 
Operatori aritmetici și operatori de comparație
În PowerShell există următorii operatori aritmetici: + (adunare), — (scădere), * (înmulțire), ⁄ (împărțire) și % (modul sau restul împărțirii). Rezultatul unei expresii aritmetice este calculat de la stânga la dreapta, conform ordinii de operare general acceptate, iar parantezele sunt utilizate pentru a grupa părțile expresiei. Spațiile dintre operatori sunt ignorate, fiind folosite doar pentru a facilita înțelegerea. Operatorul + unește, iar operatorul * repetă stringurile. Când încerci să aduni un număr la un string, acesta va fi convertit într-un string. De asemenea, în limbajul PowerShell există numeroși operatori de comparație care verifică corespondența între două valori și returnează valorile logice True sau False:
Operator
Descriere
Exemplu de cod
-eq
Echivalent / Egal (analog = sau == în alte limbaje)
$test = 100
$test -eq 123
-ne
Nu este egal / Diferit (analog sau !=)
$test = 100
$test -ne 123
-gt
Mai mare decât / Superioară (analog >)
$test = 100
$test -gt 123
-ge
Mai mare sau egal / Superioară sau egală (analog >=)
$test = 100
$test -ge 123
-lt
Mai mic decât / Inferioară (analog <)
$test = 100
$test -lt 123
-le
Mai mic sau egal / Inferioară sau egală (analog <=)
$test = 100
$test -le 123
Există și alți operatori similari care permit, de exemplu, compararea stringurilor ținând cont de caracterele wildcard sau utilizarea expresiilor regulate pentru a căuta corespondența cu un model. Acestea vor fi discutate în detaliu în articolele următoare. Caracterele și = nu sunt utilizate pentru comparație, deoarece sunt folosite în alte scopuri.
Operatori de atribuire
Pe lângă cel mai comun operator =, există și alți operatori de atribuire: +=, -=, *=, ⁄= și %=. Aceștia modifică valoarea înainte de atribuție. Se comportă similar și operatorii unari ++ și —, care cresc sau scad valoarea unei variabile — ei sunt, de asemenea, considerați operatori de atribuire.
Operatori logici
Pentru a descrie condiții complexe, o simplă comparație nu este suficientă. Orice expresie logică poate fi scrisă folosind operatori: -and, -or, -xor, -not și!.. Funcționează la fel ca în alte limbaje de programare, iar parantezele pot fi folosite pentru a specifica ordinea calculului:
("Test" -eq "Test") -and (100 -eq 100)
-not (123 -gt 321)
!(123 -gt 321)
Ramificare condițională
Operatorii de ramificare în PowerShell sunt standard: IF(IF…ELSE, IF…ELSEIF…ELSE) și SWITCH. Să examinăm utilizarea lor prin exemple:
[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 sau valoarea nu este definită"}
}
Bucle
În limbajul PowerShell există mai multe tipuri de bucle: WHILE, DO WHILE, DO UNTIL, FOR și FOREACH.
Buclele cu condiție prealabilă funcționează dacă/atunci când sunt adevărate:
[int]$test = 0
while ($test -lt 10) {
Write-Host $test
$test = $test + 1
}
Buclele cu condiție post-îndeplinită vor rula cel puțin o dată, deoarece verificarea condiției are loc după executarea iterației. Astfel, DO WHILE funcționează cât timp condiția este adevărată, iar DO UNTIL — cât timp este falsă:
[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)
Numărul de iterații al buclei FOR este cunoscut dinainte:
for ([int]$test = 0; $test -lt 10; $test++) {
Write-Host $test
}
În bucla FOREACH se realizează parcurgerea elementelor unui array sau colecție (hash map):
$test_collection = "item1", "item2", "item3"
foreach ($item in $test_collection)
{
Write-Host $item
}
Matrice
În variabilele PowerShell se pot stoca nu doar obiecte individuale (număr, șir ș.a.m.d.), ci și multiple. Cea mai simplă variantă a acestor variabile este array-urile. Un array poate conține mai multe elemente, un singur element sau poate fi gol, adică să nu conțină elemente. Pentru declarația sa se utilizează operatorul @(), care ne va fi necesar în articolul următor - este foarte important pentru adăugarea altor array-uri în array (crearea array-urilor multidimensionale), transmiterea array-urilor în funcții ca argument și sarcini de genul acesta:
$test_array = @() #creăm un array golLa inițializarea array-ului, valorile sale sunt separate prin virgulă (operatorul special ,):
$test_array = @(1, 2, 3, 4) # creăm un array din patru elemente În cele mai multe cazuri, operatorul @() poate fi omis:
$test_array = 1, 2, 3, 4În acest caz, un array cu un singur element este inițializat astfel:
$test_array = , 1Pentru accesarea elementelor array-ului se folosește un index întreg care începe de la zero și operatorul de indexare (paranteze drepte):
$test_array[0] = 1Se pot specifica mai multe indecși separați prin virgulă, inclusiv în mod repetat:
$test_array = "unu", "doi", "trei", "patru"
$test_array[0,1,2,3]
$test_array[1,1,3,3,0] 
Operator .. (două puncte — operator de interval) returnează un array de numere întregi într-un interval superior și inferior specificat. De exemplu, expresia 1..4 returnează un array cu patru elemente @(1, 2, 3, 4), iar expresia 8..5 — un array @(8, 7, 6, 5).
Folosind operatorul de interval, se poate inițializa un array ($test_array = 1..4) sau se poate obține o secvență (slice), adică o secvență de elemente dintr-un array cu indici din altul. Aici, un număr negativ -1 indică ultimul element al array-ului, -2 — penultimul și așa mai departe.
$test_array = "unu", "doi", "trei", "patru"
$test_array[0..2]
$test_array[2..0]
$test_array[-1..0]
$test_array[-2..1]Observați că valorile în array-ul de numere întregi pot depăși valoarea maximă a indexului array-ului. În acest caz, se returnează toate valorile până la ultima:
$test_array[0..100]Dacă se încearcă accesarea unui singur element inexistent în array, se returnează valoarea $null.
În PowerShell, array-urile pot conține elemente de tipuri diferite sau pot fi strict tipizate:
$test_array = 1, 2, "test", 3, 4
for ([int]$i = 0; $i -lt $test_array.count; $i++)
{
Write-Host $test_array[$i]
}
Unde proprietatea $test_array.count reprezintă numărul de elemente din array.
Exemplu de creare a unui array strict tipizat:
[int[]]$test_array = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
Tabele hash
Un alt tip de bază de variabile în PowerShell este hărțile hashtable, care sunt de asemenea denumite array-uri associative. Hashtable-urile sunt asemănătoare cu obiectele JSON și sunt construite pe baza principiului cheie-valoare. Spre deosebire de array-urile obișnuite, accesul la elementele lor se face prin chei numite, care sunt proprietăți ale obiectului (poate fi folosit și operatorul de indexare — paranteze pătrate).
O hartă hashtable goală este declarată cu simbolul special @ și paranteze operatorii:
$test_hashtable = @{}La declarație, se pot crea imediat chei și se pot atribui valori:
$test_hashtable = @{one="unu"; two="doi"; three="trei"; "some key"="some value"}Pentru a adăuga un element în harta hashtable, trebuie să i se atribuie o cheie care nu există încă sau să se folosească metoda Add(). Dacă atribuire se face cu o cheie existentă, valoarea sa se va schimba. Pentru a elimina un element din harta hashtable, se utilizează metoda Remove().
$test_hashtable."some key"
$test_hashtable["some key"]
$test_hashtable.Add("four", "patru")
$test_hashtable.five = "cinci"
$test_hashtable['five'] = "înlocuim valoarea"
$test_hashtable.Remove("one") 
Variabilele acestui tip pot fi transmise ca argumente funcțiilor și cmdlet-urilor — în articolul următor vom studia cum se face acest lucru și vom explora un alt tip similar — PSCustomObject.
Functions
În limbajul PowerShell există toate elementele necesare pentru programarea procedurală, inclusiv funcții. Pentru a le descrie se folosește cuvântul rezervat Function, după care trebuie indicat numele funcției și corpul, închise între paranteze. Dacă este necesar să se transmită argumente funcției, acestea pot fi specificate imediat după nume în paranteze rotunde.
function nume-funcție (argument1, ..., argumentN)
{
corp-funcție
}
Funcția returnează întotdeauna un rezultat — acesta este un array de rezultate ale tuturor instrucțiunilor sale, dacă sunt mai mult de una. Dacă există o singură instrucțiune, se returnează o valoare unică de tipul corespunzător. Construcția return $value adaugă un element cu valoarea $value la array-ul de rezultate și întrerupe execuția listei de instrucțiuni, iar o funcție goală returnează $null.
De exemplu, să creăm o funcție care calculează pătratul unui număr:
function sqr ($number)
{
return $number * $number
}
Observăm că în corpul funcției pot fi folosite orice variabile declarate înainte de apelul acesteia, iar apelul funcțiilor în PowerShell poate părea neobișnuit: argumentele (dacă există) nu sunt închise în paranteze rotunde și sunt separate prin spații.
sqr 2sau așa:
sqr -number 2Din cauza modului în care sunt transmise argumentele, uneori funcția însăși trebuie înfășurată în paranteze:
function test_func ($n) {}
test_func -eq $null # funcția nu a fost apelată
(test_func) -eq $null # rezultatul expresiei — $true 
Atunci când descriem o funcție, putem atribui argumentelor valori implicite:
function func ($arg = value) {
#corp funcție
}
Există și o altă sintaxă pentru descrierea argumentelor funcției, de asemenea, parametrii pot fi citiți din canal — toate acestea ne vor fi utile în articolul următor, când vom explora modulele exportate și crearea propriilor cmdlet-uri.
Gestionarea erorilor
În PowerShell există un mecanism Try…Catch…Finally care permite gestionarea situațiilor excepționale. În blocul Try se plasează codul în care poate apărea o eroare, iar în blocul Catch – handlerul acesteia. Dacă nu a fost nicio eroare, acesta nu se execută. Blocul Finally se execută după blocul Try, indiferent de apariția erorii, iar blocurile Catch pot fi mai multe pentru excepții de tipuri diferite. Excepția în sine este stocată într-o variabilă implicită care nu necesită declarație ($_) și poate fi extrasa cu ușurință. În exemplul de mai jos, implementăm o protecție împotriva introducerii unei valori incorecte:
try {
[int]$test = Read-Host "Introduceți un număr"
100 / $test
} catch {
Write-Warning "Număr incorect"
Write-Host $_
}
Pe această notă, prezentarea bazelor programării în PowerShell se încheie. În articolele următoare, vom explora mai în detaliu lucrul cu variabile de diferite tipuri, colecții, expresii regulate, crearea de funcții, module și comenzi proprii, precum și programarea orientată pe obiect.
Sursa: habr.com
