Che cos'è Windows PowerShell e con cosa viene mangiato? Parte 2: Introduzione al linguaggio di programmazione

Storicamente, le utilità della riga di comando sui sistemi Unix sono sviluppate meglio che su Windows, ma con l'avvento di una nuova soluzione la situazione è cambiata.

PowerShell può essere scriptato in un linguaggio multi-paradigma interpretato che presenta elementi della classica programmazione procedurale, orientata agli oggetti e persino funzionale: ramificazione condizionale, loop, variabili, array, tabelle hash, classi, gestione degli errori, nonché funzioni, cmdlet e pipeline. Articolo precedente era dedicato alle basi del lavoro nell'ambiente e ora offriamo ai nostri lettori un piccolo libro di riferimento per i programmatori.

Sommario:

Commenti
Variabili e loro tipi
Variabili di sistema
Ambiti
Variabili d'ambiente (ambiente)
Operatori aritmetici e di confronto
Operatori di assegnamento
Operatori logici
Salto condizionale
cicli
array
Tabelle hash
funzioni
Errore di elaborazione

Puoi scrivere codice in qualsiasi editor di testo o utilizzando un ambiente di sviluppo integrato: il modo più semplice è utilizzare Windows PowerShell ISE fornito con i sistemi operativi server Microsoft. Questo è necessario solo per script abbastanza complessi: brevi serie di comandi sono più facili da eseguire in modo interattivo.

Commenti

L'uso dei commenti è considerato parte di un buon stile di programmazione insieme a indentazione e spazi bianchi corretti:

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

<# 

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

#>

Variabili e loro tipi

Le variabili in PowerShell sono oggetti denominati. I loro nomi possono includere il carattere di sottolineatura, nonché lettere e numeri. Il simbolo $ viene sempre utilizzato prima del nome e per dichiarare una variabile è sufficiente dare all'interprete un nome valido:

Per inizializzare una variabile (assegnarle un valore), viene utilizzato l'operatore di assegnazione (simbolo =):

$test = 100

Puoi dichiarare una variabile specificandone il tipo tra parentesi quadre (operatore di casting del tipo) prima del nome o del valore:

[int]$test = 100

$test = [int]100

È importante comprendere che le variabili in PowerShell sono oggetti completi (classi) con proprietà e metodi i cui tipi sono basati su quelli in .NET Core. Elenchiamo i principali:

Tipo (classe .NET)

descrizione

Esempio di codice

[stringa] System.String

Stringa Unicode 

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

[char]System.Char

Carattere Unicode (16 bit)

[char]$prova = 'c'

[bool] System.Boolean

tipo booleano (booleano Vero o Falso)

[bool]$test = $vero

[int] System.Int32

numero intero a trentadue bit (32 bit)

[int]$test = 123456789

[lungo] System.Int64

numero intero a sessantaquattro bit (64 bit)

[lungo]$test = 12345678910

[singolo] System.Single

numero in virgola mobile lungo 32 bit

[singolo]$test = 12345.6789

[doppio]Sistema.Doppio

numero in virgola mobile di lunghezza 64 bit (8 byte)

[doppio]$test = 123456789.101112

[decimal]System.Decimal

Numero in virgola mobile a 128 bit (che deve terminare con d)

[decimale]$test = 12345.6789d

[DateTime]System.DateTime

data e ora 

$test = GetDate

[array] Sistema.Oggetto[]

un array il cui indice di elemento inizia da 0

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

[hashtable] System.Collections.Hashtable

Le tabelle hash sono array associativi con chiavi nominate, costruite secondo il principio: @{key = "value"}

$test_hashtable = @{uno="uno"; due="due"; tre="tre"}

PowerShell supporta la conversione implicita del tipo, inoltre, il tipo di una variabile può essere modificato al volo (ad esempio, utilizzando un operatore di assegnazione), se non è specificato forzatamente - in questo caso, l'interprete darà un errore. È possibile determinare il tipo di variabile dall'esempio precedente chiamando il metodo GetType():

$test.GetType().FullName

Sono disponibili numerosi cmdlet per la manipolazione delle variabili. Il loro elenco in una forma conveniente viene visualizzato utilizzando il comando:

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

Per visualizzare le variabili dichiarate e i relativi valori, è possibile utilizzare un cmdlet speciale:

Get-Variable | more

Questo metodo sembra eccessivamente macchinoso, è molto più conveniente lavorare con le variabili tramite operatori o accedendo direttamente alle loro proprietà e metodi. Tuttavia, i cmdlet hanno il diritto di esistere perché consentono di impostare alcuni parametri aggiuntivi. È importante comprendere che le variabili utente vengono definite solo all'interno della sessione corrente. Quando la console viene chiusa o lo script termina, vengono eliminati.

Variabili di sistema

Oltre a quelle dichiarate dall'utente, esistono variabili integrate (di sistema) che non vengono eliminate al termine della sessione corrente. Sono divisi in due tipi, mentre i dati di stato di PowerShell sono archiviati in variabili automatiche a cui non è possibile assegnare valori arbitrari da soli. Questi includono, ad esempio, $PWD:

$PWD.Path

Le variabili di preferenza sono necessarie per memorizzare le preferenze dell'utente, i cui valori possono essere modificati. Ad esempio, utilizzando $ErrorActionPreference , viene impostata la reazione dell'interprete dei comandi al verificarsi di errori non fatali.

Oltre agli operatori e ai cmdlet per l'accesso alle variabili dichiarate, esiste una variabile: pseudo-accumulatore. Puoi lavorarci per analogia con altre unità e le variabili in questo caso assomigliano agli oggetti del file system:

Get-ChildItem Variable: | more

o

ls Variable: | more

Ambiti

Per le variabili in PowerShell esiste il concetto di ambito (Scope). L'azione dell'ambito globale (Globale) si applica all'intera sessione corrente, includendo, ad esempio, le variabili di sistema. Le variabili locali (locali) sono disponibili solo nell'ambito in cui sono state definite: diciamo all'interno di una funzione. Esiste anche il concetto di ambito dello script (Script), ma per i comandi di script è essenzialmente locale. Per impostazione predefinita, quando si dichiarano variabili, viene assegnato loro un ambito locale e per modificarlo è necessario un costrutto speciale come: $Global: variabile = valore.

Ad esempio, questo:

$Global:test = 100

Variabili d'ambiente (ambiente)

Un'altra pseudo-unità, Env:, è disponibile in PowerShell e può essere utilizzata per accedere alle variabili di ambiente. All'avvio della shell, vengono copiati dal processo padre (ovvero dal programma che ha avviato la sessione corrente) e solitamente i loro valori iniziali sono gli stessi dei valori nel pannello di controllo. Per visualizzare le variabili di ambiente, utilizzare il cmdlet Get-ChildItem o i relativi alias (alias): ls e dir.

dir Env:

Queste variabili sono sequenze di byte (o caratteri, se preferite), la cui interpretazione dipende solo dal programma che le utilizza. I cmdlet *-Variable non funzionano con le variabili di ambiente. Per accedervi, devi utilizzare il prefisso del drive:

$env:TEST = "Hello, World!"

Operatori aritmetici e di confronto

PowerShell fornisce i seguenti operatori aritmetici: + (addizione), - (sottrazione), * (moltiplicazione), / (divisione) e % (modulo o modulo). Il risultato di un'espressione aritmetica viene valutato da sinistra a destra secondo l'ordine delle operazioni generalmente accettato e le parentesi vengono utilizzate per raggruppare parti dell'espressione. Gli spazi tra gli operatori vengono ignorati, vengono utilizzati solo per facilitarne la lettura. Anche l'operatore + concatena e l'operatore * ripete le stringhe. Se provi ad aggiungere un numero a una stringa, verrà convertito in una stringa. Inoltre, il linguaggio PowerShell ha molti operatori di confronto che controllano la corrispondenza tra due valori e restituiscono il valore booleano True o False:

operatore

descrizione

Esempio di codice

-eq

Uguale / Uguale (simile a = o == in altre lingue)

$prova = 100
$prova -eq 123 

-Ne

Non uguale / Non uguale (simile a <> o !=)

$prova = 100
$prova -ne 123   

-gt

Maggiore di / Più (analogico>)

$prova = 100
$prova -gt 123

-dare

Maggiore o uguale / Maggiore o uguale (simile a >=)

$prova = 100
$prova -ge 123

-lt

Minore di / Minore (simile a <)

$prova = 100
$prova -lt 123  

-Le

Minore o uguale / Minore o uguale (simile a <=)

$prova = 100
$prova -le 123

Esistono altri operatori simili che consentono, ad esempio, di confrontare stringhe in base a un carattere jolly o di utilizzare espressioni regolari per abbinare un modello. Li tratteremo in dettaglio nei prossimi articoli. I simboli <, > e = non vengono utilizzati per il confronto perché vengono utilizzati per altri scopi.

Operatori di assegnamento

Oltre al più comune operatore =, esistono altri operatori di assegnazione: +=, -=, *=, /= e %=. Modificano il valore prima dell'assegnazione. Gli operatori unari ++ e -, che aumentano o diminuiscono il valore di una variabile, si comportano in modo simile - si applicano anche agli operatori di assegnazione.

Operatori logici

Il confronto da solo non è sufficiente per descrivere condizioni complesse. Puoi scrivere qualsiasi espressione logica usando gli operatori: -and, -or, -xor, -not and!.. Funzionano come in altri linguaggi di programmazione, mentre puoi usare le parentesi per specificare l'ordine di valutazione:

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

-not (123 -gt 321) 

!(123 -gt 321)

Salto condizionale

Gli operatori di filiale in PowerShell sono standard: IF(IF…ELSE, IF…ELSEIF…ELSE) e SWITCH. Diamo un'occhiata al loro utilizzo con 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 ha diverse varietà di loop: WHILE, DO WHILE, DO UNTIL, FOR e FOREACH.

Un ciclo con una precondizione funziona se/fintanto che è vero:

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

I cicli con una postcondizione verranno eseguiti almeno una volta, poiché la condizione viene verificata dopo l'iterazione. Allo stesso tempo, DO WHILE funziona mentre la condizione è vera e DO UNTIL funziona mentre è 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)

Il numero di iterazioni del ciclo FOR è noto in anticipo:

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

Nel ciclo FOREACH, itera sugli elementi di un array o di una raccolta (tabella hash):

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

array

Le variabili di PowerShell memorizzano non solo singoli oggetti (numero, stringa, ecc.), ma anche più oggetti. Il tipo più semplice di tali variabili sono gli array. Un array può essere costituito da più elementi, un elemento o essere vuoto, ad es. non contengono elementi. Viene dichiarato utilizzando l'operatore @(), di cui avremo bisogno nel prossimo articolo: è molto importante per aggiungere altri array a un array (creando array multidimensionali), passare array a funzioni come argomento e attività simili:

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

Quando un array viene inizializzato, i suoi valori vengono elencati separati da virgole (operatore speciale ,):

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

Nella maggior parte dei casi, l'operatore @() può essere omesso:

$test_array = 1, 2, 3, 4

In questo caso, un array di un elemento viene inizializzato come segue

$test_array = , 1

È possibile accedere agli elementi dell'array utilizzando un indice intero in base zero e l'operatore di indice (parentesi quadre):

$test_array[0] = 1

È possibile specificare diversi indici separati da virgole, incl. ricorrenti:

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

operatore .. (due punti - operatore di intervallo) restituisce un array di numeri interi all'interno dei limiti superiore e inferiore specificati. Ad esempio, l'espressione 1..4 restituisce un array di quattro elementi @(1, 2, 3, 4) e l'espressione 8..5 restituisce un array @(8, 7, 6, 5).

Usando l'operatore range, puoi inizializzare un array ($test_array = 1..4) o ottenere una slice (slice), ad es. una sequenza di elementi di un array con indici di un altro. In questo caso, un numero negativo -1 denota l'ultimo elemento dell'array, -2 - il penultimo e così via.

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

Si noti che i valori dell'array di numeri interi possono essere maggiori del valore di indice massimo dell'array di dati. In questo caso vengono restituiti tutti i valori fino all'ultimo:

$test_array[0..100]

Se si tenta di accedere a un singolo elemento dell'array inesistente, viene restituito $null.

In PowerShell, gli array possono contenere elementi di tipi diversi o essere fortemente tipizzati:

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

Dove la proprietà $test_array.count è il numero di elementi dell'array.

Un esempio di creazione di un array fortemente tipizzato:

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

Tabelle hash

Un altro tipo base di variabili nel linguaggio PowerShell sono le tabelle hash, note anche come array associativi. Le tabelle hash sono simili agli oggetti JSON e sono costruite su base valore-chiave. A differenza degli array ordinari, ai loro elementi si accede tramite chiavi denominate, che sono proprietà dell'oggetto (puoi anche usare l'operatore di indice - parentesi quadre).

Una tabella hash vuota viene dichiarata utilizzando il simbolo @ e le parentesi dell'operatore:

$test_hashtable = @{}

Quando si dichiara, è possibile creare immediatamente chiavi e assegnare loro valori:

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

Per aggiungere un elemento a una tabella hash, devi assegnargli una chiave che non esiste ancora o utilizzare il metodo Add (). Se viene effettuata un'assegnazione a una chiave esistente, il suo valore cambierà. Il metodo Remove() viene utilizzato per rimuovere un elemento da una tabella 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 questo tipo possono essere passate come argomenti a funzioni e cmdlet: nel prossimo articolo studieremo come farlo e considereremo anche un altro tipo simile: PSCustomObject.

funzioni

PowerShell ha tutto il necessario per la programmazione procedurale, comprese le funzioni. Per descriverle si utilizza la parola funzione Function, dopo la quale è necessario specificare il nome della funzione e il corpo racchiuso tra parentesi operatore. Se devi passare argomenti alla funzione, puoi specificarli subito dopo il nome tra parentesi.

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

La funzione restituisce sempre un risultato: è un array dei risultati di tutte le sue istruzioni, se ce ne sono più di una. Se è presente una sola istruzione, viene restituito l'unico valore del tipo corrispondente. Il costrutto return $value aggiunge un elemento con il valore $value all'array dei risultati e interrompe l'esecuzione dell'elenco di istruzioni e la funzione vuota restituisce $null.

Ad esempio, creiamo una funzione per elevare al quadrato un numero:

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

Si noti che nel corpo di una funzione è possibile utilizzare qualsiasi variabile dichiarata prima di chiamarla e le funzioni di chiamata in PowerShell possono sembrare insolite: gli argomenti (se presenti) non sono racchiusi tra parentesi e sono separati da spazi.

sqr 2

o così:

sqr -number 2

A causa del modo in cui vengono passati gli argomenti, la funzione stessa a volte deve essere racchiusa tra parentesi:

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

Quando si descrive una funzione, è possibile assegnare valori predefiniti agli argomenti:

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

Esiste un'altra sintassi per descrivere gli argomenti della funzione, inoltre, i parametri possono essere letti dalla pipeline: tutto ciò tornerà utile nel prossimo articolo, quando esamineremo i moduli esportati e creeremo i nostri cmdlet.

Errore di elaborazione

PowerShell dispone di un meccanismo Try...Catch...Finally per gestire le eccezioni. Il blocco Try contiene il codice in cui può verificarsi un errore e il blocco Catch contiene il suo gestore. Se non ci sono stati errori, non viene eseguito. Il blocco Finalmente viene eseguito dopo il blocco Prova, indipendentemente dal verificarsi di un errore, e possono esserci diversi blocchi Catch per diversi tipi di eccezioni. L'eccezione stessa viene scritta in una variabile predefinita non dichiarata ($_) e può essere recuperata facilmente. Nell'esempio seguente, implementiamo la protezione contro l'inserimento di un valore non valido:

try {

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

} catch {

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

}

Questo conclude la revisione delle basi della programmazione nel linguaggio PowerShell. Nei seguenti articoli studieremo più in dettaglio il lavoro con variabili di diversi tipi, raccolte, espressioni regolari, la creazione di funzioni, moduli e cmdlet personalizzati, nonché la programmazione orientata agli oggetti.

Fonte: habr.com