Storicamente, le utilità da riga di comando nei sistemi Unix sono state sviluppate meglio rispetto a Windows, tuttavia, con l'arrivo della nuova soluzione, la situazione è cambiata.
Per PowerShell è possibile scrivere script in un linguaggio interpretato multi-paradigma, che contiene elementi di programmazione procedurale classica, orientata agli oggetti e persino funzionale: salti condizionali, cicli, variabili, array, tabelle hash, classi, gestione degli errori, oltre a funzioni, cmdlet e pipeline. era dedicata alle basi del lavoro nell'ambiente, e ora proponiamo ai lettori una piccola guida per programmatori.
Contenuto:
È possibile scrivere codice in qualsiasi editor di testo o utilizzando un ambiente di sviluppo integrato: la scelta più semplice è Windows PowerShell ISE fornito con i sistemi operativi server Microsoft. Questo è necessario solo per script abbastanza complessi: le brevi sequenze di comandi sono più facili da eseguire in modalità interattiva.
Commenti
L'uso dei commenti è considerato parte di un buon stile di programmazione, insieme a corretti rientri e spazi:
# Для строчных комментариев используется символ решетки — содержимое строки интерпретатор не обрабатывает.
<#
Так обозначаются начало и конец блочного комментария.
Заключенный между ними текст интерпретатор игнорирует.
#>
Variabili e i loro tipi
Le variabili in PowerShell sono oggetti nominati. I loro nomi possono includere un carattere di sottolineatura, oltre a lettere e numeri. Prima del nome si utilizza sempre il simbolo $, e per dichiarare una variabile è sufficiente indicare un nome valido all'interprete:
Per inizializzare una variabile (assegnarle un valore) si utilizza l'operatore di assegnazione (simbolo =):
$test = 100Una variabile può essere dichiarata specificando il suo tipo tra parentesi quadre (operatore di casting dei tipi) 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 esistenti in .NET Core. Elenchiamo i principali:
Tipo (classe .NET)
Descrizione
Esempio di codice
[string]
System.String
stringa Unicode
$test = «test»
$test = ‘test’
[char]
System.Char
carattere Unicode (16 bit)
[char]$test = ‘c’
[bool]
System.Boolean
tipo booleano (valore logico True o False)
[bool]$test = $true
[int]
System.Int32
numero intero a 32 bit (32 bit)
[int]$test = 123456789
[long]
System.Int64
numero intero a 64 bit (64 bit)
[long]$test = 12345678910
[single]
System.Single
numero in virgola mobile a 32 bit
[single]$test = 12345,6789
[double]
System.Double
numero con punto mobile lungo 64 bit (8 byte)
[double]$test = 123456789,101112
[decimal]
System.Decimal
numero con punto mobile lungo 128 bit (deve sempre finire con d)
[decimal]$test = 12345,6789d
[DateTime]
System.DateTime
data e ora
$test = Get-Date
[array]
System.Object[]
array, gli indici degli elementi iniziano 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: @{chiave = "valore"}
$test_hashtable = @{one="uno"; two="due"; three="tre"}
PowerShell supporta la conversione implicita dei tipi, inoltre il tipo di variabile può cambiare in corsa (ad esempio, utilizzando l'operatore di assegnazione), se non specificato forzatamente — in questo caso l'interprete genererà un errore. È possibile determinare il tipo di variabile dall'esempio precedente utilizzando il metodo GetType():
$test.GetType().FullName 
Esiste un certo numero di cmdlet per gestire le variabili. La loro lista viene visualizzata in modo comodo utilizzando il comando:
Get-Command -Noun Variable | ft -Property Name, Definition -AutoSize -Wrap 
Per visualizzare le variabili dichiarate e i loro valori, puoi utilizzare un cmdlet speciale:
Get-Variable | moreQuesto metodo sembra eccessivamente ingombrante, è molto più semplice lavorare con le variabili tramite operatori o accedendo direttamente alle loro proprietà e metodi. Tuttavia, i cmdlet hanno diritto di esistere poiché consentono di impostare alcuni parametri aggiuntivi. È importante comprendere che le variabili utente sono definite solo nell'ambito della sessione corrente. Dopo la chiusura della console o il termine dello script, vengono eliminati.
Variabili di sistema
Oltre alle variabili dichiarate dall'utente, esistono variabili incorporate (di sistema) che non vengono eliminate dopo la fine della sessione corrente. Si dividono in due tipi, nel caso in cui i dati sullo stato di PowerShell siano memorizzati in variabili automatiche, a cui non è possibile assegnare valori arbitrari. Tra queste, ad esempio, $PWD:
$PWD.Path 
Per memorizzare impostazioni personalizzate sono necessarie le variabili di preferenza, i cui valori possono essere modificati. Ad esempio, utilizzando $ErrorActionPreference si può impostare la reazione dell'interprete ai verificarsi di errori non critici.
In aggiunta agli operatori e ai cmdlet per accedere alle variabili dichiarate, esiste un pseudocontenitore chiamato Variable:. Può essere utilizzato analogamente ad altri contenitori, e le variabili in questo caso ricordano gli oggetti del filesystem:
Get-ChildItem Variable: | moreo
ls Variable: | more 
Ambiti di visibilità
Per le variabili in PowerShell esiste il concetto di ambito (Scope). L'azione dell'ambito globale (Global) si estende all'intera sessione corrente — include, ad esempio, le variabili di sistema. Le variabili locali (Local) sono accessibili solo nell'ambito in cui sono state definite: ad esempio all'interno di una funzione. Esiste anche il concetto di ambito di script (Script), ma per i comandi di script è sostanzialmente locale. Per impostazione predefinita, quando si dichiarano variabili, viene assegnato un ambito locale, e per cambiarlo è necessaria una sintassi speciale del tipo: $Global: variabile = valore.
Ad esempio, così:
$Global:test = 100
Variabili ambientali (di sistema)
Da PowerShell è disponibile un altro pseudocontenitore chiamato Env:, che consente di accedere alle variabili d'ambiente. Quando si avvia la shell, esse vengono copiate dal processo padre (cioè dal programma che ha avviato la sessione corrente) e di solito i loro valori iniziali corrispondono ai valori nel pannello di controllo. Per visualizzare le variabili d'ambiente si utilizza il cmdlet Get-ChildItem o i suoi alias: ls e dir.
dir Env: 
Queste variabili rappresentano 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 d'ambiente. Per accedervi, è necessario utilizzare il prefisso del disco:
$env:TEST = "Hello, World!" 
Operatori aritmetici e operatori di confronto
In PowerShell ci sono i seguenti operatori aritmétici: + (somma), — (sottrazione), * (moltiplicazione), / (divisione) e % (modulo o resto della divisione). Il risultato dell'espressione aritmetica viene calcolato da sinistra a destra secondo l'ordine delle operazioni consueto, e per raggruppare le parti dell'espressione si utilizzano le parentesi. Gli spazi tra gli operatori vengono ignorati, vengono utilizzati solo per migliorare la leggibilità. L'operatore + unisce, mentre l'operatore * ripete le stringhe. Quando si tenta di sommare un numero a una stringa, esso verrà convertito in stringa. Inoltre, nel linguaggio PowerShell esistono molti operatori di confronto che verificano la corrispondenza tra due valori e restituiscono i valori booleani True o False:
Operatore
Descrizione
Esempio di codice
-eq
Uguale / Equal (equivalente di = o == in altri linguaggi)
$test = 100
$test -eq 123
-ne
Non uguale / Not equal (equivalente di o !=)
$test = 100
$test -ne 123
-gt
Maggiore di / Greater than (equivalente di >)
$test = 100
$test -gt 123
-ge
Maggiore o uguale / Greater than or equal (equivalente di >=)
$test = 100
$test -ge 123
-lt
Minore di / Less than (equivalente di <)
$test = 100
$test -lt 123
-le
Minore o uguale / Less than or equal (equivalente di <=)
$test = 100
$test -le 123
Esistono anche altri operatori simili che consentono, ad esempio, di confrontare stringhe con caratteri jolly o utilizzare espressioni regolari per cercare corrispondenze. Li esamineremo nei prossimi articoli. I simboli ed = non vengono utilizzati per i confronti poiché sono riservati ad altri scopi.
Operatori di assegnazione
Oltre all'operatore = più comune, ci sono altri operatori di assegnazione: +=, -=, *=, /= e %= che modificano il valore prima dell'assegnazione. Si comportano in modo simile anche gli operatori unari ++ e —, che aumentano o diminuiscono il valore della variabile, e anch'essi appartengono agli operatori di assegnazione.
Operatori logici
Per descrivere condizioni complesse, è insufficiente un semplice confronto. Qualsiasi espressione logica può essere formulata usando operatori: -and, -or, -xor, -not e!.. Funzionano come in altri linguaggi di programmazione, e si possono usare le parentesi per specificare l'ordine di calcolo:
("Test" -eq "Test") -and (100 -eq 100)
-not (123 -gt 321)
!(123 -gt 321)
Salto condizionale
Gli operatori di ramificazione in PowerShell sono standard: IF(IF…ELSE, IF…ELSEIF…ELSE) e SWITCH. Esamineremo il loro utilizzo tramite 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 5 o valore non definito"}
}
Cicli
Nel linguaggio PowerShell ci sono diverse tipologie di cicli: WHILE, DO WHILE, DO UNTIL, FOR e FOREACH.
Un ciclo con condizione predefinita funziona se/finché è vero:
[int]$test = 0
while ($test -lt 10) {
Write-Host $test
$test = $test + 1
}
I cicli con condizione posticipata verranno eseguiti almeno una volta, poiché il controllo della condizione avviene dopo l'esecuzione dell'iterazione. In questo caso, DO WHILE funziona finché la condizione è vera, mentre DO UNTIL funziona finché è 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
}
Il ciclo FOREACH itera sugli elementi di un array o di una collezione (tabella hash):
$test_collection = "item1", "item2", "item3"
foreach ($item in $test_collection)
{
Write-Host $item
}
Array
Nelle variabili PowerShell non si memorizzano solo singoli oggetti (numeri, stringhe, ecc.), ma anche più oggetti. La forma più semplice di tali variabili sono gli array. Un array può consistere di più elementi, di un solo elemento o essere vuoto, cioè non contenere elementi. Per dichiararlo si utilizza l'operatore @(), che ci servirà nell'articolo successivo: è molto importante per aggiungere array ad altri array (creare array multidimensionali), passare array a funzioni come argomenti e simili:
$test_array = @() #creiamo un array vuotoDurante l'inizializzazione di un array, i suoi valori vengono elencati separati da virgole (operatore speciale ,):
$test_array = @(1, 2, 3, 4) # creiamo un array di quattro elementi Nella maggior parte dei casi, l'operatore @() può essere omesso:
$test_array = 1, 2, 3, 4In questo caso, un array di un solo elemento viene inizializzato nel seguente modo:
$test_array = , 1Per accedere agli elementi di un array si utilizza un indice numerico che inizia da zero e l'operatore di indice (parentesi quadre):
$test_array[0] = 1È possibile specificare più indici separati da virgole, anche ripetuti:
$test_array = "uno", "due", "tre", "quattro"
$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 su un determinato limite superiore e inferiore del tratto. Ad esempio, l'espressione 1..4 restituisce un array di quattro elementi @(1, 2, 3, 4), mentre l'espressione 8..5 restituisce l'array @(8, 7, 6, 5).
Con l'operatore di intervallo è possibile inizializzare un array ($test_array = 1..4) o ottenere uno slice, cioè una sequenza di elementi di un array con indici di un altro. In questo caso, il numero negativo -1 rappresenta l'ultimo elemento dell'array, -2 il penultimo e così via.
$test_array = "uno", "due", "tre", "quattro"
$test_array[0..2]
$test_array[2..0]
$test_array[-1..0]
$test_array[-2..1]Si noti che i valori di un array di numeri interi possono superare il valore massimo dell'indice dell'array con i dati. In questo caso, vengono restituiti tutti i valori fino all'ultimo:
$test_array[0..100]Se si tenta di accedere a un unico elemento non esistente dell'array, viene restituito il valore $null.
In PowerShell, gli array possono contenere elementi di tipi diversi o essere fortemente tipizzati:
$test_array = 1, 2, "test", 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.
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, che vengono anche chiamate array associativi. Le Hashtable sono simili a un oggetto JSON e si basano sul principio chiave-valore. A differenza degli array normali, l'accesso ai loro elementi avviene tramite chiavi nominate, che sono proprietà dell'oggetto (si può anche utilizzare l'operatore di indice — le parentesi quadre).
Una tabella hash vuota viene dichiarata utilizzando il simbolo @ e le parentesi operative:
$test_hashtable = @{}Al momento della dichiarazione, è possibile creare immediatamente chiavi e assegnare loro valori:
$test_hashtable = @{one="uno"; two="due"; three="tre"; "some key"="some value"}Per aggiungere un elemento a una tabella hash, è necessario assegnare una chiave non esistente o utilizzare il metodo Add(). Se l'assegnazione avviene con una chiave esistente, il suo valore verrà modificato. Per rimuovere un elemento da una tabella hash si utilizza il metodo Remove().
$test_hashtable."some key"
$test_hashtable["some key"]
$test_hashtable.Add("four", "quattro")
$test_hashtable.five = "cinque"
$test_hashtable['five'] = "sostituiamo il valore"
$test_hashtable.Remove("one") 
Le variabili di questo tipo possono essere passate come argomenti a funzioni e cmdlet: nell'articolo seguente esamineremo come fare, e vedremo anche un altro tipo simile: PSCustomObject.
Funzioni
Nel linguaggio PowerShell ci sono tutti gli elementi necessari per la programmazione procedurale, comprese le funzioni. Per descriverle si utilizza la parola chiave Function, seguita dal nome della funzione e dal corpo racchiuso tra parentesi. Se è necessario passare argomenti alla funzione, possono essere indicati subito dopo il nome tra parentesi.
function nome-funzione (argomento1, ..., argomentoN)
{
corpo-funzione
}
La funzione restituisce sempre un risultato: si tratta di un array di risultati di tutti i suoi statement, se ce ne sono più di uno. Se c'è un solo statement, viene restituito un solo valore del tipo corrispondente. La costruzione return $value aggiunge un elemento con il valore $value all'array dei risultati e interrompe l'esecuzione della statement list, mentre una funzione vuota restituisce $null.
Ad esempio, creiamo una funzione per elevare un numero al quadrato:
function sqr ($number)
{
return $number * $number
}
Nota che nel corpo della funzione si possono usare tutte le variabili dichiarate prima della sua chiamata, e la chiamata di funzioni in PowerShell può sembrare insolita: gli argomenti (se ci sono) non sono racchiusi tra parentesi e sono separati da spazi.
sqr 2o così:
sqr -number 2A causa del modo in cui vengono passati gli argomenti, a volte è necessario racchiudere la funzione tra parentesi:
function test_func ($n) {}
test_func -eq $null # la funzione non è stata chiamata
(test_func) -eq $null # il risultato dell'espressione è $true 
Quando si descrive una funzione, si possono assegnare valori predefiniti agli argomenti:
function func ($arg = value) {
#corpo della funzione
}
Esiste anche un'altra sintassi per descrivere gli argomenti della funzione, inoltre i parametri possono essere letti dal pipeline: tutto questo sarà utile nel prossimo articolo, quando esploreremo i moduli esportati e la creazione dei propri cmdlet.
Gestione degli errori
In PowerShell esiste un meccanismo Try…Catch…Finally che consente di gestire le situazioni eccezionali. Nel blocco Try si inserisce il codice in cui potrebbe verificarsi un errore, mentre nel blocco Catch si trova il gestore dell'errore. Se non ci sono errori, il blocco Catch non viene eseguito. Il blocco Finally viene eseguito dopo il blocco Try indipendentemente dal verificarsi di un errore, e possono esserci più blocchi Catch per eccezioni di diversi tipi. L'eccezione stessa viene registrata in una variabile predefinita ($_) che non richiede dichiarazione e può essere facilmente estratta. Nell'esempio sottostante implementiamo una protezione per l'inserimento di un valore non valido:
try {
[int]$test = Read-Host "Inserisci un numero"
100 / $test
} catch {
Write-Warning "Numero non valido"
Write-Host $_
}
Con questo si conclude la nostra introduzione ai fondamenti della programmazione in PowerShell. Negli articoli successivi approfondiremo il lavoro con variabili di diversi tipi, collezioni, espressioni regolari, creazione di funzioni, moduli e cmdlet personalizzati, oltre alla programmazione orientata agli oggetti.
Fonte: habr.com
