TUTORIAL POWERSHELL - PARTE 5 - SCRIPT

Tutorial introduttivo all'utilizzo di PowerShell, a prima vista una estensione del prompt dei comandi di Microsoft Windows ma che in realtà è molto di più.






Lista completa articoli su Tutorial PowerShell [link]

Abilitare Script

Prima di procedere con l'argomento, è necessario sapere che, di default, l'esecuzione di Script in PowerShell è disabilitata.. o meglio: è ristretta. 

In qualunque Sistema Operativo sia installato PowerShell, l'esecuzione di Script è vincolata dalle regole di Execution Policy. Queste regole impediscono l'esecuzione di Script PowerShell secondo quattro livelli:

• Restricted (l'esecuzione non è permessa) 
• AllSigned (l'esecuzione è permessa se associata ad una firma digitale)
• RemoteSigned (l'esecuzione degli script locali è permessa, quelli remoti devono essere associati ad una firma digitale)
• Unrestricted (l'esecuzione è permessa) 

Per verificare quale sia il livello di ExecutionPolicy si utilizza il cmdlet Get-ExecutionPolicy

Dato che lo scopo di questo tutorial è utilizzare PowerShell come strumento di programmazione, impostiamo il nostro livello di sicurezza a RemoteSigned, un buon compromesso fra la sicurezza ed elasticità. Per modificare l'Execution Policy si utilizza il cmdlet Set-ExecutionPolicy 

Attenzione: per eseguire il cmdlet Set-ExecutionPolicy è necessario eseguire una sessione di PowerShell privilegiata come già descritto nel Tutorial [link].

Variabili

Sono state spese parole riguardo gli oggetti ma vediamo come è possibile definire delle variabili in PowerShell. Le variabili in PowerShell sono sempre precedute dal simbolo dollaro ($):

$myVar = "hello world"

Per ottenere il valore della variabile è sufficiente digitarne il nome

Nota: Come abbiamo già detto in precedenza [link] PowerShell non è case sensitive, quindi il modo in cui viene scritto il nome della variabile non è importante ($myvariable equivale a $MYVARIABLE).

A differenza di altri linguaggi di Scripting, dove le variabili non sono tipizzate, in PowerShell le variabili acquistano il tipo dell'oggetto assegnato.

• $var = "hello", indica implicitamente che si tratta di una stringa
• $var = 3, indica implicitamente che si tratta di un numero
• $var = $true, indica implicitamente che si tratta di un booleano
• $var = (dir text.txt) indica implicitamente che si tratta di un oggetto.

Per esempio, se avessimo definito una variabile numerica $myNumber ed effettuassimo una concatenazione di stringa otterremmo il seguente errore:

Il vantaggio di avere variabili non tipizzate sta nel fatto che assegnando un valore ad una variabile essa cambia tipo in favore del nuovo valore.

In PowerShell vengono gestiti tutti i tipi di dato presenti nel Framework .Net:

• Numeri (bool, byte, int, float, double...)
• Caratteri (string, char...)
• Oggetti .Net

Script

Gli Script PowerShell non sono altro che file di testo che contengono cmdlet ed istruzioni, un tipico file sorgente. I file hanno estensione PS1 e possono essere eseguiti tramite PowerShell.exe.

Utilizziamo PowerShell ISE per creare il nostro primo script:

Scope

Quando viene aperta una sessione di PowerShell, tutte le variabili che vengono realizzate vengono mantenute in memoria volatile fino alla chiusura della console (o sessione). Analogamente, le variabili che vengono definite all'interno di uno script vengono mantenute in memoria fino alla terminazione dello script. Questo concetto viene chiamato Scope.

Nota: utilizzando PowerShell ISE lo Scope è automaticamente condiviso fra editor e console.

Verifichiamo quanto appena detto creando uno script che utilizza al suo interno una variabile, se si prova ad accedere alla variabile creata dallo script non sarà possibile ottenerne il valore::

Per fare in modo che le variabili create all'interno di uno script siano accessibili all'interno dello Scope della sessione PowerShell che esegue lo script è necessario precedere lo script dal carattere punto (.):

. .\script.ps1

In questo modo sarà possibile ottenere il contenuto della variabile creata nello script, al di fuori di esso:

Parametri

Dopo aver visto come creare uno script ed eseguirlo passiamo ad utilizzare i parametri. I parametri passati ad uno script vengono restituiti eseguendo il metodo Param() all'interno dello script; il metodo Param() inserisce all'interno della variabile passata come parametro l'array di parametri passati allo script.

Esempio: proviamo a realizzare uno script che effettua un "hello-qualcosa"

Param($something)
$hello = "hello " + $something
$hello

Se lo script viene chiamato con due parametri il risultato sarà lo stesso

Per utilizzare il secondo parametro è necessario aggiungere una variabile al metodo Param():

Param($something,$somethingelse)
$hello = "hello " + $something + " " + $somethingelse
$hello

Nota: Param() deve essere inserito nella prima riga dello script.

Output

Fino ad ora per mostrare un output da console è stato utilizzata la forma implicita delle variaibli:

$myVar = "value"
$myVar #"value" in console

Utilizzando il cmdlet Write-Output è possibile mostrare un output a schermo:

Write-Output "hello world"

Se proviamo a modificare lo script di "hello-qualcosa" utilizzando Write-Output però ci accorgiamo di una differenza sostanziale:

Il cmdlet Write-Output percepisce ogni singolo parametro come una variaibile, per ottenere il vecchio output è necessario modificare lo script:

Param($who)
Write-Output "hello $who"

Input

Abbiamo appena visto come scrivere sulla console un testo, allo stesso modo è possibile leggere giò che viene digitato a schermo dall'utente tramite il cmdlet Read-Host:

$input = Read-Host

Il cmdlet può essere anche utilizzato in combinazione con un testo, per mostrare un messaggio prima di acquisire l'input:

$username= Read-Host "username: "

Infine è possibile anche mascherare l'input da tastiera (Avevamo già trattato l'argomento in .Net [link]), per acquisire un input senza mostrarlo a schermo:

$password = Read-Host "password: " -AsSecureString

In questo caso però l'oggetto che viene restituito dal cmdlet non è di tipo Stringa, ma di tipo System.Security.SecureString, un particolare oggetto del Framework .Net per memorizzare informazioni sensibili. Per ottenere il contenuto di una SecureString è necessario utilizzare il seguente codice:

[Runtime.InteropServices.Marshal]::PtrToStringAuto(
[Runtime.InteropServices.Marshal]::SecureStringToBSTR($password))

I dettagli di quanto è stato appena scritto verranno affrontati in un prossimo articolo [link].

Logica

Come tutti i linguaggi di programmazione, esistono gli operatori di logica (if, cicli...). Per quando possa sembrare un argomento banale, ci troviamo finalmente davanti alla differenza più grande e, secondo me, ad un difetto di PowerShell: gli operandi di comparazione.

PowerShell non ammette l'utilizzo dei classici operandi di comparazione, ma richiede che essi siano specificati come flag di comparazione. Nella tabella è possibile notare la conversione degli operandi in flag:

OPERANDO	C#	PowerShell
uguaglianza	==	-eq
disuguaglianza	!=	-ne
minore	<	-lt
minore o uguale	<=	-le
maggiore	>	-gt
maggiore o uguale	>=	-ge
negazione	!	-not
and	&&	-and
or	||	-or
like		-like

Per quanto questo sia un Tutorial Introduttivo di PowerShell, non è così basilare per spendere troppo tempo su semplici concetti (come IF) nel dettaglio. Limitiamoci ad un semplice elenco:

• IF

if($myVar -eq 3){
   Write-Output "something"
}else{
   Write-Output "something else"
}

• WHILE

$myVar = 3
while($myVar -lt 4){
   Write-Output "CTRL+C TO CLOSE"
}

• FOR

for($i=0; $i -le 10; i++){
   Write-Output $i
}

• FOREACH

$myNumbers = "one","two","three"
foreach($n in $myNumbers){
   Write-Output $n
}

Profile

Come ultimo argomento riguardo gli Script PowerShell, vediamo cosa sono i Profili. Un Profilo è uno speciale script che viene eseguito all'avvio di una sessione PowerShell. Se non specificato, viene caricato un profilo predefinito il cui contenuto è possibile consultarlo tramite la variabile $profile:

$profile

Per quanto riguarda i Profili, a questo punto, basta sapere che inserendo del codice all'interno del profilo predefinito, esso sarà eseguito all'avvio della sessione PowerShell.

Conclusione

Finalmente siamo arrivati ad analizzare un po' di programmazione, abbiamo visto come utilizzare le variabili ed eseguire script. Nel prossimo articolo [link] entreremo ancora più nel dettaglio introducendo le Funzioni.