Què és Windows PowerShell i amb què es menja? Part 2: Introducció al llenguatge de programació

Històricament, les utilitats de línia d'ordres als sistemes Unix estan millor desenvolupades que a Windows, però amb l'arribada d'una nova solució, la situació ha canviat.

PowerShell us permet escriure scripts en un llenguatge interpretat i multiparadigma que conté elements de la programació clàssica de procediments, orientats a objectes i fins i tot funcionals: branca condicional, bucles, variables, matrius, taules hash, classes, tractament d'errors, així com funcions, cmdlets i pipelines . Article anterior es va dedicar als conceptes bàsics del treball en l'entorn, i ara oferim als nostres lectors un petit llibre de referència per a programadors.

Taula de continguts:

Comentaris
Variables i els seus tipus
Variables del sistema
Àmbit
Variables del mediambient
Operadors aritmètics i de comparació
Operadors d'assignació
Operadors lògics
Salt condicional
Cicles
Matrius
Taules hash
Funcions
Error en processar

Podeu escriure codi en qualsevol editor de text o utilitzar un entorn de desenvolupament integrat; la manera més senzilla és agafar Windows PowerShell ISE que ve amb els sistemes operatius de servidor de Microsoft. Això només és necessari per a scripts bastant complexos: els conjunts curts d'ordres són més fàcils d'executar de manera interactiva.

Comentaris

L'ús de comentaris es considera part d'un bon estil de programació, juntament amb el sagnat i els espais en blanc adequats:

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

<# 

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

#>

Variables i els seus tipus

Les variables de PowerShell són objectes amb nom. Els seus noms poden incloure el caràcter de subratllat, així com lletres i números. El nom sempre va precedit d'un símbol $, i per declarar una variable, només cal que proporcioneu a l'intèrpret un nom vàlid:

Per inicialitzar una variable (assignar-li un valor), utilitzeu l'operador d'assignació (el símbol =):

$test = 100

Podeu declarar una variable indicant-ne el tipus entre claudàtors (operador d'emissió de tipus) abans del nom o valor:

[int]$test = 100

$test = [int]100

És important entendre que les variables de PowerShell són objectes (classes) complets amb propietats i mètodes, els tipus dels quals es basen en els que es troben a .NET Core. Enumerem els principals:

Tipus (classe .NET)

Descripció

Exemple de codi

[cadena] System.String

Cadena Unicode 

$test = "prova"
$test = 'prova'

[char]System.Char

Caràcter Unicode (16 bits)

[char]$test = 'c'

[bool] System.Boolean

tipus booleà (valor booleà Vertader o Fals)

[bool]$test = $true

[int]System.Int32

nombre enter de trenta-dos bits (32 bits)

[int]$test = 123456789

[llarg] System.Int64

nombre enter de seixanta-quatre bits (64 bits)

[llarg]$test = 12345678910

[single]System.Single

nombre de coma flotant de 32 bits de llarg

[únic]$test = 12345.6789

[doble]Sistema.Doble

nombre de coma flotant de 64 bits de llarg (8 bytes)

[doble]$test = 123456789.101112

[decimal] Sistema.Decimal

nombre de coma flotant de 128 bits de llarg (ha d'incloure d al final)

[decimal]$test = 12345.6789d

[DateTime] System.DateTime

дата i время 

$test = data d'obtenció

[matriu]System.Object[]

una matriu l'índex d'elements de la qual comença a 0

$test_array = 1, 2, "prova", 3, 4

[taula hash] System.Collections.Hashtable

Les taules hash són matrius associatives amb claus anomenades, construïdes segons el principi: @{key = "valor"}

$test_hashtable = @{one="one"; dos = "dos"; tres="tres"}

PowerShell admet la conversió de tipus implícita i el tipus d'una variable es pot canviar sobre la marxa (per exemple, utilitzant un operador d'assignació) tret que sigui forçada, en aquest cas l'intèrpret llançarà un error. Podeu determinar el tipus de variable a partir de l'exemple anterior cridant al mètode GetType():

$test.GetType().FullName

Hi ha una sèrie de cmdlets per gestionar variables. Es mostra una llista d'ells en un format convenient mitjançant l'ordre:

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

Per veure les variables declarades i els seus valors, podeu utilitzar un cmdlet especial:

Get-Variable | more

Aquest mètode sembla massa feixuc; és molt més convenient treballar amb variables mitjançant operadors o accedint directament a les seves propietats i mètodes. Tanmateix, els cmdlets tenen el seu lloc perquè us permeten establir alguns paràmetres addicionals. És important entendre que les variables d'usuari només es defineixen dins de la sessió actual. Un cop es tanca la consola o s'ha completat l'script, se suprimeixen.

Variables del sistema

A més de les declarades per l'usuari, hi ha variables integrades (del sistema) que no s'eliminen un cop finalitza la sessió actual. Es divideixen en dos tipus, amb dades d'estat de PowerShell emmagatzemades en variables automàtiques a les quals no es poden assignar valors arbitraris. Aquests inclouen, per exemple, $PWD:

$PWD.Path

Per emmagatzemar les preferències de l'usuari, calen variables de preferència els valors de les quals es puguin canviar. Per exemple, amb $ErrorActionPreference podeu establir la reacció de l'intèrpret d'ordres davant errors no crítics.

A més dels operadors i cmdlets per accedir a les variables declarades, hi ha la Variable: pseudo-acumulador. Podeu treballar-hi per analogia amb altres unitats, i les variables en aquest cas s'assemblen als objectes del sistema de fitxers:

Get-ChildItem Variable: | more

o

ls Variable: | more

Àmbit

Les variables de PowerShell tenen un concepte anomenat Scope. L'àmbit global s'aplica a tota la sessió actual; inclou, per exemple, variables del sistema. Les variables locals només estan disponibles en l'àmbit on es van definir: per exemple, dins d'una funció. També hi ha el concepte d'abast de l'script (Script), però per a les ordres d'script és essencialment local. Per defecte, quan es declaren variables, se'ls dóna un àmbit local, i per canviar-ho, necessiteu una construcció especial com: $Global: variable = valor.

Per exemple, així:

$Global:test = 100

Variables del mediambient

Hi ha una altra pseudo-unitat disponible a PowerShell, Env:, que podeu utilitzar per accedir a les variables d'entorn. Quan s'inicia l'intèrpret d'ordres, es copien del procés principal (és a dir, del programa que va iniciar la sessió actual) i normalment els seus valors inicials coincideixen amb els valors del tauler de control. Per veure les variables d'entorn, utilitzeu el cmdlet Get-ChildItem o els seus àlies: ls i dir.

dir Env:

Aquestes variables són seqüències de bytes (o caràcters, si ho preferiu), la interpretació de les quals depèn només del programa que les utilitzi. *-Els cmdlets de variables amb variables d'entorn no funcionen. Per referir-vos-hi, haureu d'utilitzar el prefix de disc:

$env:TEST = "Hello, World!"

Operadors aritmètics i de comparació

PowerShell té els operadors aritmètics següents: + (suma), - (resta), * (multiplicació), / (divisió) i % (mòdul o resta de divisió). El resultat d'una expressió aritmètica s'avalua d'esquerra a dreta segons l'ordre d'operacions generalment acceptat, i s'utilitzen parèntesis per agrupar parts de l'expressió. Els espais entre operadors s'ignoren i només s'utilitzen per facilitar la lectura. L'operador + també concatena i l'operador * repeteix les cadenes. Si intenteu afegir un número a una cadena, es convertirà en una cadena. A més, PowerShell té molts operadors de comparació que comparen dos valors i retornen un booleà True o False:

Operador

Descripció

Exemple de codi

-eq

Igual / Igual (anàloga a = o == en altres idiomes)

$prova = 100
$test -eq 123 

- és

No igual / No igual (anàloga a <> o !=)

$prova = 100
$prova -ne 123   

-gt

Més gran que / Més (analògic >)

$prova = 100
$test -gt 123

-ge

Major que o igual / Major que o igual (analògic >=)

$prova = 100
$test -ge 123

-lt

Menys de/Menys (analògic <)

$prova = 100
$test -lt 123  

-la

Menor o igual / Menor o igual (analògic <=)

$prova = 100
$test -le 123

Hi ha altres operadors similars que us permeten, per exemple, comparar cadenes amb comodins o utilitzar expressions regulars per fer coincidir un patró. Els veurem amb detall als articles següents. Els símbols <, > i = no s'utilitzen per a la comparació perquè s'utilitzen per a altres finalitats.

Operadors d'assignació

A més de l'operador més comú =, hi ha altres operadors d'assignació: +=, -=, *=, /= i %=. Canvien el valor abans de l'assignació. Els operadors unaris ++ i -, que augmenten o disminueixen el valor d'una variable, es comporten de la mateixa manera: també pertanyen als operadors d'assignació.

Operadors lògics

La comparació per si sola no és suficient per descriure condicions complexes. Podeu escriure qualsevol expressió lògica utilitzant els operadors: -and, -or, -xor, -not i!... Funcionen com en altres llenguatges de programació, però podeu utilitzar parèntesis per especificar l'ordre de càlcul:

("Тест" -eq "Тест") -and (100 -eq 100)

-not (123 -gt 321) 

!(123 -gt 321)

Salt condicional

Els operadors de ramificació a PowerShell són estàndard: IF(IF...ELSE, IF...ELSEIF...ELSE) i SWITCH. Vegem el seu ús amb exemples:

[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 или значение не определено"}
}

Cicles

PowerShell té diversos tipus de bucles: WHILE, DO WHILE, DO UNTIL, FOR i FOREACH.

S'executa un bucle amb una condició prèvia si/mentre és cert:

[int]$test = 0
while ($test -lt 10) {
      Write-Host $test
      $test = $test + 1
}

Els bucles amb una condició posterior s'executaran almenys una vegada, perquè la condició es comprova després de completar la iteració. En aquest cas, DO WHILE funciona mentre la condició és certa i DO UNTIL funciona mentre és falsa:

[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)

El nombre d'iteracions del bucle FOR es coneix per endavant:

for ([int]$test = 0; $test -lt 10; $test++) {
       Write-Host $test
}

Al bucle FOREACH, itera a través dels elements d'una matriu o col·lecció (taula hash):

$test_collection = "item1", "item2", "item3"
foreach ($item in $test_collection)
{
        Write-Host $item
}

Matrius

Les variables de PowerShell emmagatzemen no només objectes únics (número, cadena, etc.), sinó també diversos. El tipus més senzill d'aquestes variables són les matrius. Una matriu pot constar de diversos elements, un element o estar buida, és a dir. no contenen elements. Per declarar-ho, utilitzem l'operador @(), que necessitarem a l'article següent; és molt important per afegir altres matrius a una matriu (creant matrius multidimensionals), passar matrius a funcions com a argument i tasques similars:

$test_array = @() #создаем пустой массив

En inicialitzar una matriu, els seus valors s'enumeren separats per comes (operador especial ,):

$test_array = @(1, 2, 3, 4) # создаем массив из четырех элементов 

En la majoria dels casos, l'operador @() es pot ometre:

$test_array = 1, 2, 3, 4

En aquest cas, una matriu d'element únic s'inicialitza de la manera següent

$test_array = , 1

Per accedir als elements de la matriu, utilitzeu un índex enter de base zero i l'operador d'índex (parèntesis):

$test_array[0] = 1

Podeu especificar diversos índexs separats per comes, incl. repetint:

$test_array = "один", "два", "три", "четыре"
$test_array[0,1,2,3]
$test_array[1,1,3,3,0]

Operador .. (dos punts - operador d'interval) retorna una matriu d'enters en un límit superior i inferior especificat. Per exemple, l'expressió 1..4 dóna sortida a una matriu de quatre elements @(1, 2, 3, 4) i l'expressió 8..5 genera una matriu @(8, 7, 6, 5).

Mitjançant l'operador d'interval, podeu inicialitzar una matriu ($test_array = 1..4) o obtenir una porció, és a dir. una seqüència d'elements d'una matriu amb índexs d'una altra. En aquest cas, el número negatiu -1 denota l'últim element de la matriu, -2 - el penúltim, etc.

$test_array = "один", "два", "три", "четыре"
$test_array[0..2]
$test_array[2..0]
$test_array[-1..0]
$test_array[-2..1]

Tingueu en compte que els valors d'una matriu d'enters poden ser superiors al valor màxim de l'índex de la matriu de dades. En aquest cas, es retornen tots els valors fins a l'últim:

$test_array[0..100]

Si intenteu accedir a un únic element de matriu inexistent, es retorna el valor $null.

A PowerShell, les matrius poden contenir elements de diferents tipus o estar ben escrites:

$test_array = 1, 2, "тест", 3, 4
for ([int]$i = 0; $i -lt $test_array.count; $i++)
{
          Write-Host $test_array[$i]
}

On la propietat $test_array.count és el nombre d'elements de la matriu.

Un exemple de creació d'una matriu fortament tipificada:

[int[]]$test_array = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9

Taules hash

Un altre tipus bàsic de variable a PowerShell són les taules hash, també anomenades matrius associatives. Les taules hash són similars als objectes JSON i es construeixen en funció del valor-clau. A diferència de les matrius normals, s'accedeix als seus elements mitjançant claus amb nom, que són propietats de l'objecte (també podeu utilitzar l'operador d'índex - claudàtors).

Es declara una taula hash buida utilitzant el símbol @ i els claudàtors de l'operador:

$test_hashtable = @{}

En declarar, podeu crear claus immediatament i assignar-hi valors:

$test_hashtable = @{one="один"; two="два"; three="три"; "some key"="some value"}

Per afegir un element a una taula hash, cal assignar-li una clau que encara no existeix o utilitzar el mètode Add(). Si es fa una assignació a una clau existent, el seu valor canviarà. Per eliminar un element de la taula hash, utilitzeu el mètode Remove().

$test_hashtable."some key"
$test_hashtable["some key"]
$test_hashtable.Add("four", "четыре")
$test_hashtable.five = "пять"
$test_hashtable['five'] = "заменяем значение"
$test_hashtable.Remove("one")

Les variables d'aquest tipus es poden passar com a arguments a funcions i cmdlets; al següent article estudiarem com es fa això i també veurem un altre tipus similar: PSCustomObject.

Funcions

PowerShell té tot el que necessiteu per a la programació de procediments, incloses les funcions. Per descriure'ls, s'utilitza la paraula de servei Funció, després de la qual cal indicar el nom de la funció i el cos entre claudàtors de l'operador. Si necessiteu passar arguments a la funció, es poden especificar immediatament després del nom entre parèntesis.

function имя-функции (аргумент1, ..., аргументN) 
{ 
        тело-функции 
} 

La funció sempre retorna un resultat: aquesta és una matriu de resultats de totes les seves declaracions, si n'hi ha més d'una. Si només hi ha una instrucció, es retorna un únic valor del tipus corresponent. La construcció $value de retorn afegeix un element amb el valor $value a la matriu de resultats i avorta l'execució de la llista de declaracions, mentre que una funció buida retorna $null.

Per exemple, creem una funció per quadrar un nombre:

function sqr ($number)
{
      return $number * $number
}

Tingueu en compte que al cos d'una funció podeu utilitzar qualsevol variable declarada abans de ser cridada, i cridar funcions a PowerShell pot semblar inusual: els arguments (si n'hi ha) no estan entre parèntesis i estan separats per espais.

sqr 2

més o menys:

sqr -number 2

A causa de la manera com es passen els arguments, la funció en si mateixa de vegades s'ha d'entregar entre parèntesis:

function test_func ($n) {}
test_func -eq $null     # функция не вызывалась
(test_func) -eq $null   # результат выражения — $true

Quan es descriu una funció, podeu assignar valors per defecte als arguments:

function func ($arg = value) {
         #тело функции
}

També hi ha una altra sintaxi per descriure els arguments de la funció, i els paràmetres també es poden llegir des del pipeline; tot això us serà útil en el proper article, quan mirem l'exportació de mòduls i la creació dels vostres propis cmdlets.

Error en processar

PowerShell té un mecanisme Try...Catch...Finally que us permet gestionar situacions d'excepció. El bloc Try conté codi en què es pot produir un error i el bloc Catch conté el seu controlador. Si no hi ha hagut error, no s'executa. El bloc Finally s'executa després del bloc Try, independentment de si es produeix un error, i hi pot haver diversos blocs Catch per a diferents tipus d'excepcions. L'excepció en si s'escriu en una variable predeterminada no declarada ($_) i es pot recuperar fàcilment. A l'exemple següent, implementem protecció contra introduir un valor incorrecte:

try {

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

} catch {

         Write-Warning "Некорректное число"
         Write-Host $_

}

Aquí és on hauríem d'acabar la nostra revisió dels conceptes bàsics de programació a PowerShell. En articles futurs, analitzarem més de prop el treball amb variables de diferents tipus, col·leccions, expressions regulars, la creació de funcions, mòduls i els vostres propis cmdlets, així com la programació orientada a objectes.

Font: www.habr.com