Cosa hè Windows PowerShell è ciò chì si manghja? Parte 2: Introduzione à a lingua di prugrammazione

Stòricamente, l'utilità di linea di cumanda in i sistemi Unix sò megliu sviluppati chì in Windows, ma cù l'avventu di una nova suluzione, a situazione hà cambiatu.

PowerShell pò esse scripted in una lingua interpretata, multi-paradigma chì hà elementi di prugrammazione classica procedurale, orientata à l'ughjettu, è ancu funziunale: branching conditional, loops, variables, arrays, hash tables, classi, gestione d'errore, è ancu funzioni, cmdlet, è pipeline. Articulu precedente era dedicatu à i principii di u travagliu in l'ambiente, è avà offre à i lettori una piccula guida per i programatori.

Table di cuntenutu:

Comments
Variabili è i so tipi
Variabili di u sistema
Scopes
Variabili di l'ambiente (ambienti)
Operatori aritmetici è paraguni
Operatori di assignazione
Operatori logichi
Saltu Conditional
Cicli
Matrici
Tavulini Hash
Funzioni
Trattamentu di errore

Pudete scrive codice in qualsiasi editore di testu o utilizendu un ambiente di sviluppu integratu - u modu più faciule hè di piglià u Windows PowerShell ISE chì vene cù i sistemi operativi di u servitore Microsoft. Questu hè necessariu solu per scripts abbastanza cumplessi: sette brevi di cumandamenti sò più faciuli di eseguisce interattivamente.

Comments

L'usu di i cumenti hè cunsideratu parte di un bonu stilu di prugrammazione cù l'indentazione curretta è u spaziu biancu:

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

<# 

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

#>

Variabili è i so tipi

Variables in PowerShell sò chjamati oggetti. I so nomi ponu include u caratteru di underscore, è ancu lettere è numeri. U simbulu $ hè sempre usatu prima di u nome, è per dichjarà una variàbile, hè abbastanza per dà à l'interprete un nome validu:

Per inizializà una variabile (assignà un valore à ellu), l'operatore di assignazione (simbulu =) hè utilizatu:

$test = 100

Pudete dichjarà una variàbbili specificendu u so tipu in parentesi quadrate (operatore di casting di tipu) prima di u nome o valore:

[int]$test = 100

$test = [int]100

Hè impurtante di capisce chì e variàbili in PowerShell sò oggetti cumpleti (classi) cù pruprietà è metudi chì i tipi sò basati nantu à quelli in .NET Core. Listemu i principali:

Tipu (classe .NET)

discrizzione

Esempiu di codice

[stringa] System.String

stringa Unicode 

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

[char]System.Char

Carattere Unicode (16 bits)

[char]$test = 'c'

[bool] System.Boolean

tipu booleanu (booleanu veru o falsu)

[bool]$test = $true

[int] System.Int32

trentadui bit integer (32 bit)

[int]$test = 123456789

[long] System.Int64

sessantaquattru bit integer (64 bit)

[longu]$test = 12345678910

[single] System.Single

numero in virgola flottante di 32 bit di lunghezza

[single]$test = 12345.6789

[double]Sistema.Doppiu

numeru in virgola flottante di lunghezza 64 bits (8 bytes)

[double]$test = 123456789.101112

[decimale]Sistema.Decimale

Numeru in virgola flottante di 128 bit (necessariu per finisce cù d)

[decimale]$test = 12345.6789d

[DateTime]System.DateTime

data è ora 

$test = GetDate

[array] System.Object[]

un array chì l'indice di l'elementu principia da 0

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

[hashtable] System.Collections.Hashtable

I tavulini di hash sò arrays associativi cù chjavi chjamati, custruitu secondu u principiu: @{key = "value"}

$test_hashtable = @{one="one"; dui = "dui"; trè = "trè"}

PowerShell sustene a cunversione di u tipu implicitu, in più, u tipu di una variàbile pò esse cambiatu nantu à a mosca (per esempiu, utilizendu un operatore di assignazione), se ùn hè micca specificatu per forza - in questu casu, l'interprete darà un errore. Pudete determinà u tipu di variabile da l'esempiu precedente chjamendu u metu GetType ():

$test.GetType().FullName

Ci hè una quantità di cmdlets per manipulà variàbili. A so lista in una forma còmuda hè visualizata cù u cumandimu:

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

Per vede e variabili dichjarate è i so valori, pudete aduprà un cmdlet speciale:

Get-Variable | more

Stu metudu pare troppu ingombrante, hè assai più còmuda di travaglià cù variàbili attraversu l'operatori o accede à e so proprietà è i metudi direttamente. In ogni casu, i cmdlets anu u dirittu di esiste perchè permettenu di stabilisce alcuni parametri supplementari. Hè impurtante di capisce chì e variàbili di l'utilizatori sò definite solu in a sessione attuale. Quandu a cunsola hè chjusa o u script finisci, sò sguassati.

Variabili di u sistema

In più di quelli dichjarati da l'utilizatori, ci sò variabili integrati (sistema) chì ùn sò micca sguassati dopu a fine di a sessione attuale. Sò divisi in dui tipi, mentre chì i dati di u statu di PowerShell sò almacenati in variabili automatiche chì ùn ponu micca esse attribuiti valori arbitrarii per sè stessu. Questi include, per esempiu, $PWD:

$PWD.Path

Variabili di preferenza sò necessarii per almacenà e preferenze di l'utilizatori, chì i valori ponu esse cambiati. Per esempiu, usendu $ErrorActionPreference, a reazione di l'interprete di cumandamentu à l'occurrence di errori non fatali hè stabilitu.

In più di l'operatori è i cmdlets per accede à e variabili dichjarate, ci hè una Variable: pseudo-accumulator. Pudete travaglià cun ellu per analogia cù altre unità, è e variàbili in questu casu s'assumiglia à l'uggetti di u sistema di schedari:

Get-ChildItem Variable: | more

o

ls Variable: | more

Scopes

Per i variàbili in PowerShell, ci hè u cuncettu di scope (Scope). L'azzione di u scopu glubale (Global) s'applica à tutta a sessione attuale - include, per esempiu, variàbili di u sistema. Variabili lucali (locali) sò dispunibuli solu in u scopu induve sò stati definiti: dì in una funzione. Ci hè ancu u cuncettu di u scopu di u script (Script), ma per i cumandamenti di script, hè essenzialmente lucale. Per automaticamente, quandu si dichjaranu variabili, sò datu un scopu lucale, è per cambià questu, avete bisognu di una custruzzione speciale cum'è: $Global: variable = value.

Per esempiu, cusì:

$Global:test = 100

Variabili di l'ambiente (ambienti)

Un altru pseudo-drive, Env:, hè dispunibule da PowerShell è pò esse usatu per accede à e variabili di l'ambiente. Quandu a cunchiglia principia, sò copiati da u prucessu parent (vale à dì, da u prugramma chì hà iniziatu a sessione attuale) è di solitu i so valori iniziali sò listessi cum'è i valori in u pannellu di cuntrollu. Per vede e variabili di l'ambiente, utilizate u cmdlet Get-ChildItem o i so alias (aliases): ls è dir.

dir Env:

Queste variabili sò sequenze di bytes (o caratteri, se vulete), l'interpretazione di quale dipende solu da u prugramma chì l'utiliza. I cmdlets *-Variable ùn funziona micca cù variabili di l'ambiente. Per accede à elli, avete aduprà u prefissu di l'unità:

$env:TEST = "Hello, World!"

Operatori aritmetici è paraguni

PowerShell furnisce i seguenti operatori aritmetici: + (addizione), - (sottrazioni), * (multiplicazione), / (divisione) è % (modulu o modulo). U risultatu d'una espressione aritmetica hè evaluatu da a manca à a diritta in cunfurmità cù l'ordine generale accettatu di l'operazioni, è i parentesi sò usati per aggrupà parti di l'espressione. I spazii trà l'operatori sò ignorati, sò usati solu per fà più faciule di leghje. L'operatore + cuncatena ancu, è l'operatore * ripete e stringhe. Se pruvate d'aghjunghje un numeru à una stringa, serà cunvertita in una stringa. Inoltre, a lingua PowerShell hà assai operatori di paragone chì verificanu una corrispondenza trà dui valori è tornanu u boolean True o False:

Operatore

discrizzione

Esempiu di codice

-eq

Uguali / Uguali (simile à = o == in altre lingue)

$test = 100
$test -eq 123 

- ne

Micca uguale / Micca uguale (simile à <> o !=)

$test = 100
$test -ne 123   

- gt

Più grande di / Più (analogicu>)

$test = 100
$test -gt 123

-ge

Maior ca o uguale / Maior ca o uguale (simile à >=)

$test = 100
$test -ge 123

-lt

Meno di / Meno (simile à <)

$test = 100
$test -lt 123  

-a

Less than or equal / Less than or equal (simile à <=)

$test = 100
$test -le 123

Ci sò altri operatori simili chì vi permettenu, per esempiu, paragunà strings basati nantu à un wildcard o aduprà espressioni regulari per currisponde à un mudellu. Li copreremu in dettagliu in articuli futuri. I simboli <, > è = ùn sò micca usati per paragunà perchè sò usati per altri scopi.

Operatori di assignazione

In più di l'operatore = più cumuni, ci sò altri operatori di assignazione: +=, -=, *=, /= è %=. Cambianu u valore prima di l'assignazione. L'operatori unarii ++ è -, chì aumentanu o diminuite u valore di una variabile, si cumportanu in modu simili - sò ancu applicati à l'operatori di assignazione.

Operatori logichi

A comparazione sola ùn hè micca abbastanza per discrìviri cundizioni cumplessi. Pudete scrive qualsiasi spressione lògica cù l'operatori: -and, -or, -xor, -not è! .. Funcionanu cum'è in altri linguaggi di prugrammazione, mentre chì pudete aduprà parentesi per specificà l'ordine di valutazione:

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

-not (123 -gt 321) 

!(123 -gt 321)

Saltu Conditional

L'operatori di filiale in PowerShell sò standard: IF(IF...ELSE, IF...ELSEIF...ELSE) è SWITCH. Fighjemu u so usu cù esempi:

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

Cicli

PowerShell hà parechje varietà di loops: WHILE, DO WHILE, DO UNTIL, FOR, è FOREACH.

Un ciclu cù una precondizione funziona se / finu à chì hè vera:

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

I loops cù una postcondizione correranu almenu una volta, perchè a cundizione hè verificata dopu l'iterazione. À u listessu tempu, DO WHILE funziona mentre a cundizione hè vera, è DO UNTIL funziona mentre hè 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)

U numeru di iterazioni di u ciclu FOR hè cunnisciutu in anticipu:

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

In u ciclu FOREACH, iterate nantu à l'elementi di una matrice o cullizzioni (tavola hash):

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

Matrici

E variabili di PowerShell almacenanu micca solu oggetti unichi (numeru, stringa, etc.), ma ancu parechji. U tipu più simplice di tali variàbili sò array. Un array pò esse cumpostu di parechji elementi, un elementu, o esse viotu, i.e. ùn cuntene micca elementi. Hè dichjarata cù l'operatore @(), chì avemu bisognu in l'articulu dopu - hè assai impurtante per aghjunghje altre array à un array (creendu arrays multidimensionali), passendu arrays à funzioni cum'è argumentu, è travaglii simili:

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

Quandu un array hè inizializatu, i so valori sò listati separati da virgule (operatore speciale ,):

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

In a maiò parte di i casi, l'operatore @() pò esse omessi:

$test_array = 1, 2, 3, 4

In questu casu, un array di un elementu hè inizializatu cum'è seguitu

$test_array = , 1

L'elementi di l'array sò accessu à l'usu di un indice integer basatu in zero è l'operatore d'indici (parentesi quadrati):

$test_array[0] = 1

Pudete specificà parechji indici separati da virgule, incl. recurrente:

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

Operatore .. (dui punti - operatore di intervallu) restituisce un array di interi in i limiti superiori è inferiori specificati. Per esempiu, l'espressione 1..4 produce un array di quattru elementi @(1, 2, 3, 4), è l'espressione 8..5 produce un array @(8, 7, 6, 5).

Utilizendu l'operatore di gamma, pudete inizializà un array ($test_array = 1..4) o uttene una fetta (slice), i.e. una sequenza di elementi da un array cù indici da un altru. In questu casu, un numeru negativu -1 denota l'ultimu elementu di l'array, -2 - u penultimu, è cusì.

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

Innota chì i valori di l'array integer pò esse più grande di u valore massimu di l'indice di a matrice di dati. In questu casu, tutti i valori sò tornati finu à l'ultimu:

$test_array[0..100]

Se pruvate d'accede à un unicu elementu di array inesistente, $null hè tornatu.

In PowerShell, l'arrays ponu cuntene elementi di diversi tipi o esse assai tipati:

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

Induve a pruprietà $test_array.count hè u numeru di elementi di array.

Un esempiu di creà un array forte tipatu:

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

Tavulini Hash

Un altru tipu basu di variàbili in a lingua PowerShell sò tavule hash, cunnisciute ancu com'è array associative. Hashtables sò simili à l'uggetti JSON è sò custruiti nantu à una basa di chjave-valore. A cuntrariu di l'array ordinariu, i so elementi sò accessu da e chjavi chjamati, chì sò pruprietà di l'ughjettu (pudete ancu aduprà l'operatore d'indici - parentesi quadrate).

Una tavola di hash vacante hè dichjarata cù u simbulu @ è i parentesi di l'operatore:

$test_hashtable = @{}

Quandu dichjarà, pudete creà immediatamente chjave è assignà valori à elli:

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

Per aghjunghje un elementu à una tavola hash, deve assignà una chjave chì ùn esiste micca, o aduprate u metudu Add (). Se una assignazione hè fatta à una chjave esistente, u so valore cambierà. U metudu Remove () hè utilizatu per sguassà un elementu da una table hash.

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

Variabili di stu tipu pò esse passatu cum'è argumenti à e funzioni è cmdlets - in u prossimu articulu avemu da studià cumu questu hè fattu, è ancu cunsiderà un altru tipu simili - PSCustomObject.

Funzioni

PowerShell hà tuttu ciò chì avete bisognu per a prugrammazione procedurale, cumprese funzioni. Per discrìviri, a parolla funzione Function hè aduprata, dopu à quale avete bisognu di specificà u nome di a funzione è u corpu chjusu in parentesi di l'operatore. Sè avete bisognu di passà argumenti à a funzione, pudete specificà immediatamente dopu à u nome in parentesi.

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

A funzione torna sempre un risultatu - hè un array di i risultati di tutte e so dichjarazioni, se ci sò più di unu. Se ci hè una sola dichjarazione, l'unicu valore di u tipu currispundente hè tornatu. A custruzzione di $value di ritornu aghjunghje un elementu cù u valore $value à l'array di u risultatu è abortisce l'esekzione di a lista di dichjarazione, è a funzione viota torna $null.

Per esempiu, creamu una funzione per squaring un numeru:

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

Innota chì in u corpu di una funzione, pudete aduprà qualsiasi variàbili dichjarate prima di chjamà, è e funzioni di chjamà in PowerShell pò pare micca inusual: l'argumenti (se ci sò) ùn sò micca chjusi in parentesi è sò separati da spazii.

sqr 2

o quì

sqr -number 2

A causa di a manera chì l'argumenti sò passati, a funzione stessu deve esse chjusu in parentesi:

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

Quandu si descrizanu una funzione, pudete assignà valori predeterminati à l'argumenti:

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

Ci hè una altra sintassi per a descrizzione di l'argumenti di funzione, in più, i paràmetri ponu esse leghjiti da u pipeline - tuttu questu serà utile in l'articulu dopu, quandu guardemu moduli esportati è creanu i nostri cmdlets.

Trattamentu di errore

PowerShell hà un Try... Catch...Finally mecanismu per trattà l'eccezzioni. U bloccu Try cuntene u codice in quale un errore pò accade, è u bloccu Catch cuntene u so gestore. Se ùn ci era micca errore, ùn hè micca eseguitu. U bloccu Finally hè eseguitu dopu à u bloccu Try, indipendentemente da l'occurrence di un errore, è ci ponu esse parechji blocchi Catch per diversi tipi d'eccezzioni. L'eccezzioni stessu hè scritta à una variabile predeterminata micca dichjarata ($_) è pò esse recuperata facilmente. In l'esempiu sottu, implementemu a prutezzione contru à inserisce un valore invalidu:

try {

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

} catch {

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

}

Questu cuncludi a rivista di i principii di prugrammazione in a lingua PowerShell. In l'articuli seguenti, studiaremu in più detail u travagliu cù variàbili di diversi tipi, cullezzione, espressioni rigulari, creazione di funzioni, moduli è cmdlets persunalizati, è ancu di prugrammazione orientata à l'ughjettu.

Source: www.habr.com