Condividi tramite

Tutto quello che c'è da sapere sull'istruzione if

Come in molti altri linguaggi, in PowerShell sono disponibili istruzioni per l'esecuzione condizionale di codice negli script. Tra queste, è presente l'istruzione If. In questo documento verrà approfondito uno dei comandi più importanti di PowerShell.

Nota

La versione originale di questo articolo è apparsa sul blog scritto da @KevinMarquette. Il team di PowerShell ringrazia Kevin per averne condiviso il contenuto. È possibile visitare il suo blog all'indirizzo PowerShellExplained.com.

Esecuzione condizionale

Gli script spesso devono prendere decisioni ed eseguire una logica diversa in base a tali decisioni. Questo è ciò che si intende per esecuzione condizionale. Vi è un'istruzione o un valore da valutare, quindi viene eseguita una sezione diversa del codice in base a tale valutazione. Questo è esattamente ciò che fa l'istruzione if.

Istruzione if

Di seguito è riportato un esempio di base dell'istruzione if:

$condition = $true
if ( $condition )
{
    Write-Output "The condition was true"
}

La prima operazione eseguita dall'istruzione if è valutare l'espressione tra parentesi. Se il valore restituito è $true, viene eseguito l'oggetto scriptblock tra parentesi graffe. Se il valore è $false, il blocco di script viene ignorato.

Nell'esempio precedente l'istruzione if valuta semplicemente la variabile $condition. Se il valore è $true viene eseguito il comando Write-Output all'interno del blocco di script.

In alcuni linguaggi è possibile inserire una singola riga di codice dopo l'istruzione if affinché venga eseguita. Ciò non avviene in PowerShell. Per il corretto funzionamento, è necessario fornire un oggetto scriptblock completo racchiuso tra parentesi graffe.

Operatori di confronto

L'uso più comune dell'istruzione if è il confronto tra due elementi. PowerShell offre operatori speciali per diversi scenari di confronto. Quando si usa un operatore di confronto, il valore sul lato sinistro viene confrontato con quello sul lato destro.

-eq per l'uguaglianza

L'operatore -eq esegue un controllo di uguaglianza tra due valori per verificare che siano uguali tra loro.

$value = Get-MysteryValue
if ( 5 -eq $value )
{
    # do something
}

In questo esempio viene usato un valore noto di 5 che viene confrontato con $value per verificare la corrispondenza.

Un possibile caso d'uso consiste nel controllare lo stato di un valore prima di intraprendere un'azione. È possibile avere un servizio e verificare che lo stato sia in esecuzione prima di chiamare Restart-Service.

In altri linguaggi, come C#, è comune usare == per il controllo dell'uguaglianza, ad esempio 5 == $value, ma ciò non funziona con PowerShell. Un altro errore comune che gli utenti fanno è usare il segno di uguale (ad esempio, 5 = $value) che è riservato per l'assegnazione di valori alle variabili. Inserendo il valore noto a sinistra, si commette un errore.

Questo operatore (come altri) presenta alcune varianti.

  • -eq uguaglianza senza distinzione maiuscole/minuscole
  • -ieq uguaglianza senza distinzione maiuscole/minuscole
  • -ceq uguaglianza con distinzione maiuscole/minuscole

-ne per la disuguaglianza

Molti operatori hanno un operatore correlato che controlla il risultato opposto. L'operatore -ne verifica che i valori non siano uguali tra loro.

if ( 5 -ne $value )
{
    # do something
}

Usare questo operatore per assicurarsi che l'azione venga eseguita solo se il valore non è 5. Un caso d'uso valido consiste nel verificare se un servizio si trova nello stato in esecuzione prima di provare ad avviarlo.

Varianti:

  • -ne disuguaglianza senza distinzione maiuscole/minuscole
  • -ine disuguaglianza senza distinzione maiuscole/minuscole
  • -cne disuguaglianza con distinzione maiuscole/minuscole

Si tratta di varianti inverse di -eq. Questi tipi verranno raggruppati insieme quando si elencano le varianti per altri operatori.

-gt -ge -lt -le per una relazione di maggioranza o minoranza

Questi operatori vengono usati per controllare se un valore è maggiore o minore di un altro valore. -gt -ge -lt -le rappresentano gli operatori GreaterThan, GreaterThanOrEqual, LessThan e LessThanOrEqual.

if ( $value -gt 5 )
{
    # do something
}

Varianti:

  • -gt maggiore di
  • -igt maggiore di, senza distinzione maiuscole/minuscole
  • -cgt maggiore di, con distinzione maiuscole/minuscole
  • -ge maggiore o uguale a
  • -ige maggiore o uguale a, senza distinzione maiuscole/minuscole
  • -cge maggiore o uguale a, con distinzione maiuscole/minuscole
  • -lt minore di
  • -ilt minore di, senza distinzione maiuscole/minuscole
  • -clt minore di, con distinzione maiuscole/minuscole
  • -le minore o uguale a
  • -ile minore o uguale a, senza distinzione maiuscole/minuscole
  • -cle minore o uguale a, con distinzione maiuscole/minuscole

Non è chiaro il motivo per usare opzioni con e senza distinzione maiuscole/minuscole per questi operatori.

-like per la corrispondenza con caratteri jolly

PowerShell ha una propria sintassi di criteri di ricerca basati su caratteri jolly che è possibile usare con l'operatore -like. Questi modelli con caratteri jolly sono piuttosto semplici.

  • ? trova la corrispondenza con qualsiasi carattere singolo
  • * trova la corrispondenza con un numero qualsiasi di caratteri
$value = 'S-ATX-SQL01'
if ( $value -like 'S-*-SQL??')
{
    # do something
}

È importante sottolineare che il modello trova la corrispondenza con l'intera stringa. Se è necessario trovare una corrispondenza con un elemento al centro della stringa, inserire * in entrambe le estremità della stringa.

$value = 'S-ATX-SQL02'
if ( $value -like '*SQL*')
{
    # do something
}

Varianti:

  • -like carattere jolly senza distinzione maiuscole/minuscole
  • -ilike carattere jolly senza distinzione maiuscole/minuscole
  • -clike carattere jolly con distinzione maiuscole/minuscole
  • -notlike carattere jolly non corrispondente senza distinzione maiuscole/minuscole
  • -inotlike carattere jolly non corrispondente senza distinzione maiuscole/minuscole
  • -cnotlike carattere jolly non corrispondente con distinzione maiuscole/minuscole

-match per un'espressione regolare

L'operatore -match consente di controllare una stringa per una corrispondenza basata su un'espressione regolare. Usare questo operatore quando i modelli con caratteri jolly non sono sufficientemente flessibili.

$value = 'S-ATX-SQL01'
if ( $value -match 'S-\w\w\w-SQL\d\d')
{
    # do something
}

Per impostazione predefinita, un modello regex trova la corrispondenza in qualsiasi punto della stringa. È quindi possibile specificare una sottostringa di cui si vuole trovare una corrispondenza, come illustrato di seguito:

$value = 'S-ATX-SQL01'
if ( $value -match 'SQL')
{
    # do something
}

Regex è un elemento del linguaggio complesso che vale la pena approfondire. In un altro articolo sono disponibili maggiori informazioni su -match e sui molti usi delle espressioni regolari.

Varianti:

  • -match regex senza distinzione maiuscole/minuscole
  • -imatch regex senza distinzione maiuscole/minuscole
  • -cmatch regex con distinzione maiuscole/minuscole
  • -notmatch regex non corrispondente senza distinzione maiuscole/minuscole
  • -inotmatch regex non corrispondente senza distinzione maiuscole/minuscole
  • -cnotmatch regex non corrispondente con distinzione maiuscole/minuscole

-is per il tipo

È possibile controllare il tipo di un valore con l'operatore -is.

if ( $value -is [string] )
{
    # do something
}

È utile usare questo operatore se si lavora con le classi o si accettano oggetti diversi nella pipeline. L'input può essere costituito da un servizio o da un nome di servizio. Controllare quindi se è disponibile un servizio e recuperare il servizio se si ha solo il nome.

if ( $Service -isnot [System.ServiceProcess.ServiceController] )
{
    $Service = Get-Service -Name $Service
}

Varianti:

  • -is di tipo
  • -isnot non di tipo

Operatori di raccolta

Quando si usano gli operatori precedenti con un singolo valore, il risultato è $true o $false. Questo comportamento è leggermente diverso quando si lavora con una raccolta. Ogni elemento della raccolta viene valutato e l'operatore restituisce ogni valore che dà come risultato $true.

PS> 1,2,3,4 -eq 3
3

Questa operazione funziona ancora correttamente in un'istruzione if . Se quindi viene restituito un valore dall'operatore, l'intera istruzione è $true.

$array = 1..6
if ( $array -gt 3 )
{
    # do something
}

C'è una piccola trappola nascosta nei dettagli qui che ho bisogno di sottolineare. Quando si usa l'operatore -ne in questo modo, è facile esaminare erroneamente la logica all'indietro. Quando si usa -ne con una raccolta, viene restituito $true se un elemento della raccolta non corrisponde al valore.

PS> 1,2,3 -ne 4
1
2
3

Questo può sembrare un espediente intelligente, ma gli operatori -contains e -in gestiscono questa situazione in modo più efficiente. E -notcontains restituisce i risultati previsti.

contiene

L'operatore -contains controlla la presenza di un valore nella raccolta. Appena viene trovata una corrispondenza, viene restituito $true.

$array = 1..6
if ( $array -contains 3 )
{
    # do something
}

Questo è il modo migliore per verificare se una raccolta contiene un valore. Se si usa Where-Object (o -eq) viene esaminato ogni volta l'intero elenco e l'operazione è notevolmente più lenta.

Varianti:

  • -contains corrispondenza senza distinzione maiuscole/minuscole
  • -icontains corrispondenza senza distinzione maiuscole/minuscole
  • -ccontains corrispondenza con distinzione maiuscole/minuscole
  • -notcontains mancata corrispondenza senza distinzione maiuscole/minuscole
  • -inotcontains mancata corrispondenza senza distinzione maiuscole/minuscole
  • -cnotcontains mancata corrispondenza con distinzione maiuscole/minuscole

-in

L'operatore -in è analogo all'operatore -contains ad eccezione del fatto che la raccolta si trova sul lato destro.

$array = 1..6
if ( 3 -in $array )
{
    # do something
}

Varianti:

  • -in corrispondenza senza distinzione maiuscole/minuscole
  • -iin corrispondenza senza distinzione maiuscole/minuscole
  • -cin corrispondenza con distinzione maiuscole/minuscole
  • -notin mancata corrispondenza senza distinzione maiuscole/minuscole
  • -inotin mancata corrispondenza senza distinzione maiuscole/minuscole
  • -cnotin mancata corrispondenza con distinzione maiuscole/minuscole

Operatori logici

Gli operatori logici vengono usati per invertire o combinare altre espressioni.

-not

L'operatore -not capovolge un'espressione da $false a $true o da $true a $false. Di seguito è riportato un esempio in cui si vuole eseguire un'azione quando Test-Path è $false.

if ( -not ( Test-Path -Path $path ) )

La maggior parte degli operatori analizzati offre una variante che non richiede l'uso dell'operatore -not. Talvolta, tuttavia, questo operatore è comunque utile.

! Operatore

È possibile usare ! come alias per -not.

if ( -not $value ){}
if ( !$value ){}

L'operatore ! viene spesso usato da utenti abituati con altri linguaggi, ad esempio C#. Può essere preferibile digitare per intero il nome dell'operatore perché altrimenti risulta difficile da individuare quando si esaminano rapidamente gli script.

-and

È possibile combinare espressioni con l'operatore -and. Quando si esegue questa operazione, è necessario che entrambi i lati siano $true affinché l'intera espressione sia $true.

if ( ($age -gt 13) -and ($age -lt 55) )

In questo esempio, $age deve essere 13 o maggiore per il lato sinistro e minore di 55 per il lato destro. Sono state inserite parentesi aggiuntive per rendere l'esempio più chiaro, ma tali parentesi sono facoltative se l'espressione è semplice. Di seguito è riportato lo stesso esempio senza tali parentesi.

if ( $age -gt 13 -and $age -lt 55 )

La valutazione viene eseguita da sinistra a destra. Se il primo elemento restituisce $false, l'istruzione si interrompe e non esegue il confronto di destra. Ciò è utile quando è necessario assicurarsi che un valore esista prima di usarlo. Test-Path, ad esempio, genera un errore se si fornisce un percorso $null.

if ( $null -ne $path -and (Test-Path -Path $path) )

-or

L'operatore -or consente di specificare due espressioni e restituisce $true se una di esse è $true.

if ( $age -le 13 -or $age -ge 55 )

Analogamente all'operatore -and, la valutazione viene eseguita da sinistra a destra. La differenza è che se la prima parte è $true, l'intera istruzione è $true e il resto dell'espressione non viene elaborato.

Notare inoltre il funzionamento della sintassi per questi operatori. Sono necessarie due espressioni separate. Alcuni utenti cercano di usare espressioni come $value -eq 5 -or 6 senza rendersi conto dell'errore.

-xor or esclusivo

Questo operatore è piuttosto insolito. -xor consente che una sola espressione restituisca $true. Se quindi entrambi gli elementi sono $false o se entrambi sono $true, l'intera espressione è $false. Un altro modo per descrivere il funzionamento di questo operatore è che l'espressione è $true solo quando i risultati dell'espressione sono diversi.

È raro che qualcuno usi questo operatore logico ed è difficile trovare un valido esempio in cui può essere utile usarlo.

Operatori bit per bit

Gli operatori bit per bit eseguono calcoli sui bit all'interno dei valori e producono un nuovo valore come risultato. L'insegnamento degli operatori bit per bit non rientra nell'ambito di questo articolo, ma ecco l'elenco di tali operatori .

  • -band AND binario
  • -bor OR binario
  • -bxor OR esclusivo binario
  • -bnot NOT binario
  • -shl spostamento a sinistra
  • -shr spostamento a destra

Espressioni PowerShell

È possibile usare normali espressioni PowerShell all'interno dell'istruzione condizionale.

if ( Test-Path -Path $Path )

L'oggetto Test-Path restituisce $true o $false quando viene eseguito. Ciò si applica anche ai comandi che restituiscono altri valori.

if ( Get-Process Notepad* )

Restituisce $true se è presente un processo restituito e $false , in caso contrario, . È possibile usare espressioni di pipeline o altre istruzioni di PowerShell come nell'esempio seguente:

if ( Get-Process | Where Name -eq Notepad )

Queste espressioni possono essere combinate tra loro con gli operatori -and e -or, ma può essere necessario usare parentesi per suddividerle in sottoespressioni.

if ( (Get-Process) -and (Get-Service) )

Ricerca di $null

Se non c'è alcun risultato o se il risultato è un valore $null, viene restituito $false nell'istruzione if. Quando si cerca in modo specifico $null, è consigliabile inserire $null sul lato sinistro.

if ( $null -eq $value )

Quando si gestiscono i valori $null in PowerShell, ci sono alcuni piccoli particolari da tenere presenti. Se si è interessati ad approfondire l'argomento, è disponibile l'articolo Tutto quello che c'è da sapere su $null.

Assegnazione di variabili all'interno della condizione

Questa sezione è stata aggiunta grazie ai suggerimenti di Prasoon Karunan V.

if ($process=Get-Process notepad -ErrorAction ignore) {$process} else {$false}

In genere, quando si assegna un valore a una variabile, il valore non viene passato alla pipeline o alla console. Quando si esegue un'assegnazione di variabile in una sottoespressione, questa viene passata alla pipeline.

PS> $first = 1
PS> ($second = 2)
2

Come si può vedere, l'assegnazione $first non ha alcun output, mentre l'assegnazione $second sì. Quando un'assegnazione viene eseguita in un'istruzione if, viene eseguita esattamente come l'assegnazione $second precedente. Ecco un chiaro esempio dell'uso:

if ( $process = Get-Process Notepad* )
{
    $process | Stop-Process
}

Se a $process viene assegnato un valore, l'istruzione è $true e $process si arresta.

Assicurarsi di non confondere questo caso con -eq, perché non si tratta di un controllo di uguaglianza. Si tratta di una funzionalità più complessa, del cui funzionamento la maggior parte delle persone non è a conoscenza.

Assegnazione di variabili da scriptblock

È anche possibile usare lo scriptblock dell'istruzione if per assegnare un valore a una variabile.

$discount = if ( $age -ge 55 )
{
    Get-SeniorDiscount
}
elseif ( $age -le 13 )
{
    Get-ChildDiscount
}
else
{
    0.00
}

Ogni blocco di script scrive i risultati dei comandi o il valore come output. È possibile assegnare il risultato dell'istruzione if alla $discount variabile . Per questo esempio è anche possibile assegnare semplicemente i valori alla variabile $discount direttamente in ogni blocco di script. In una situazione di questo tipo non si usa spesso if, ma può capitare di farlo.

Percorso di esecuzione alternativo

L'istruzione if consente di specificare un'azione non solo per quando l'istruzione è $true, ma anche per quando è $false. Qui entra in gioco l'istruzione else.

else

L'istruzione else è sempre l'ultima parte dell'istruzione if, quando viene usata.

if ( Test-Path -Path $Path -PathType Leaf )
{
    Move-Item -Path $Path -Destination $archivePath
}
else
{
    Write-Warning "$path doesn't exist or isn't a file."
}

In questo esempio si controlla $path per assicurarsi che si tratti di un file. Se il file viene trovato, si passa a esso. In caso contrario, viene scritto un avviso. Questo tipo di logica di diramazione è molto comune.

if annidato

Le istruzioni if e else accettano un blocco di script, quindi è possibile inserire al loro interno qualsiasi comando di PowerShell, inclusa un'altra istruzione if. In questo modo è possibile usare una logica molto più complessa.

if ( Test-Path -Path $Path -PathType Leaf )
{
    Move-Item -Path $Path -Destination $archivePath
}
else
{
    if ( Test-Path -Path $Path )
    {
        Write-Warning "A file was required but a directory was found instead."
    }
    else
    {
        Write-Warning "$path could not be found."
    }
}

In questo esempio prima viene testato il percorso e quindi viene eseguita un'azione su di esso. Se l'operazione ha esito negativo, viene eseguito un altro controllo e vengono fornite all'utente informazioni più dettagliate.

elseif

Non ci sono limiti per il numero di controlli condizionali. È possibile concatenare le istruzioni if e else invece di annidarle, usando l'istruzione elseif.

if ( Test-Path -Path $Path -PathType Leaf )
{
    Move-Item -Path $Path -Destination $archivePath
}
elseif ( Test-Path -Path $Path )
{
    Write-Warning "A file was required but a directory was found instead."
}
else
{
    Write-Warning "$path could not be found."
}

L'esecuzione avviene dall'alto verso il basso. L'istruzione if superiore viene valutata per prima. Se è $false, ci si sposta verso il basso all'istruzione elseif o else successiva nell'elenco. L'ultima istruzione else rappresenta l'azione predefinita da eseguire se nessuna delle altre istruzioni restituisce $true.

switch

A questo punto, è necessario esaminare l'istruzione switch. Questa istruzione fornisce una sintassi alternativa per eseguire più confronti con un valore. Con switch è possibile specificare un'espressione e il risultato viene confrontato con diversi valori. Se uno di questi valori corrisponde, viene eseguito il blocco di codice corrispondente. Osservare l'esempio seguente:

$itemType = 'Role'
switch ( $itemType )
{
    'Component'
    {
        'is a component'
    }
    'Role'
    {
        'is a role'
    }
    'Location'
    {
        'is a location'
    }
}

Ci sono tre possibili valori che possono corrispondere a $itemType. In questo caso, la corrispondenza è con Role. È stato usato un esempio semplice solo per fornire un'idea dell'operatore switch. Per maggiori informazioni, è disponibile l'articolo Tutto quello che c'è da sapere sull'istruzione switch.

Matrice inline

Si ha una funzione denominata Invoke-SnowSql che avvia un eseguibile con diversi argomenti della riga di comando. Ecco un frammento di questa funzione in cui viene creata la matrice di argomenti.

$snowSqlParam = @(
    '--accountname', $Endpoint
    '--username', $Credential.UserName
    '--option', 'exit_on_error=true'
    '--option', 'output_format=csv'
    '--option', 'friendly=false'
    '--option', 'timing=false'
    if ($Debug)
    {
        '--option', 'log_level=DEBUG'
    }
    if ($Path)
    {
        '--filename', $Path
    }
    else
    {
        '--query', $singleLineQuery
    }
)

Le variabili $Debug e $Path sono parametri della funzione forniti dall'utente finale. Vengono valutati inline nell'inizializzazione della matrice. Se $Debug è true, i valori rientrano in $snowSqlParam nella posizione corretta. Lo stesso vale per la variabile $Path.

Semplificare le operazioni complesse

È inevitabile che capitino situazioni in cui sono presenti troppi confronti da controllare e l'istruzione If scorre molto verso destra sullo schermo.

$user = Get-ADUser -Identity $UserName
if ( $null -ne $user -and $user.Department -eq 'Finance' -and $user.Title -match 'Senior' -and $user.HomeDrive -notlike '\\server\*' )
{
    # Do Something
}

In tal caso il codice può essere difficile da leggere ed è più facile commettere errori. Ci sono alcuni modi per risolvere un problema di questo tipo.

Continuazione di riga

In PowerShell ci sono alcuni operatori che consentono di eseguire il wrapping del comando alla riga successiva. Gli operatori logici -and e -or sono ideali da usare se si vuole suddividere l'espressione in più righe.

if ($null -ne $user -and
    $user.Department -eq 'Finance' -and
    $user.Title -match 'Senior' -and
    $user.HomeDrive -notlike '\\server\*'
)
{
    # Do Something
}

Il contenuto rimane molto, ma posizionare ogni parte su una riga separata fa una grande differenza. In genere si usa questa soluzione quando sono presenti più di due confronti o se è necessario scorrere verso destra per leggere la logica.

Pre-calcolo dei risultati

È possibile estrarre l'istruzione dall'istruzione if e controllare solo il risultato.

$needsSecureHomeDrive = $null -ne $user -and
    $user.Department -eq 'Finance' -and
    $user.Title -match 'Senior' -and
    $user.HomeDrive -notlike '\\server\*'

if ( $needsSecureHomeDrive )
{
    # Do Something
}

Si tratta di un'operazione molto più immediata rispetto all'esempio precedente. È anche possibile usare un nome di variabile che spieghi cosa si sta realmente controllando. Anche questo è un esempio di codice autodocumentato che consente di evitare commenti non necessari.

Più istruzioni If

È possibile suddividere un'istruzione in più istruzioni e controllarle una alla volta. In questo caso, si usa un flag o una variabile di verifica per combinare i risultati.


$skipUser = $false

if( $null -eq $user )
{
    $skipUser = $true
}

if( $user.Department -ne 'Finance' )
{
    Write-Verbose "isn't in Finance department"
    $skipUser = $true
}

if( $user.Title -match 'Senior' )
{
    Write-Verbose "Doesn't have Senior title"
    $skipUser = $true
}

if( $user.HomeDrive -like '\\server\*' )
{
    Write-Verbose "Home drive already configured"
    $skipUser = $true
}

if ( -not $skipUser )
{
    # do something
}

Per il corretto funzionamento della logica dei flag, è necessario invertire la logica. Ogni valutazione è una singola istruzione if. Il vantaggio in questo caso è che quando si esegue il debug, è possibile capire esattamente cosa sta facendo la logica. Allo stesso tempo, è possibile aggiungere un livello di dettaglio molto migliore.

L'ovvio svantaggio è la necessità di scrivere più codice. Il codice è più complesso da esaminare perché una singola riga di logica viene esplosa in 25 o più righe.

Uso delle funzioni

È anche possibile spostare tutta la logica di convalida in una funzione. Come si può vedere, il risultato è molto più ordinato.

if ( Test-SecureDriveConfiguration -ADUser $user )
{
    # do something
}

È comunque necessario creare la funzione per eseguire la convalida, ma il codice è molto più facile da gestire. È anche più semplice testare il codice. Nei test è possibile simulare la chiamata a Test-ADDriveConfiguration e sono necessari solo due test per questa funzione. Uno che restituisce $true e uno che restituisce $false. Il test dell'altra funzione è più semplice perché è molto piccola.

Il corpo di tale funzione può comunque essere quello di una sola riga con cui si è iniziato oppure la logica esplosa usata nell'ultima sezione. Questo approccio funziona bene per entrambi gli scenari e consente di modificare in modo semplice l'implementazione in un secondo momento.

Gestione degli errori

Un uso importante dell'istruzione if è il controllo della presenza di condizioni di errore prima che gli errori si verifichino. È ad esempio possibile controllare l'esistenza di una cartella prima di provare a crearla.

if ( -not (Test-Path -Path $folder) )
{
    New-Item -Type Directory -Path $folder
}

Se ci si aspetta che si verifichi un'eccezione, allora non si tratta realmente di un'eccezione. Controllare quindi i valori e convalidare le condizioni quando possibile.

Se si vuole approfondire la gestione delle eccezioni, è disponibile l'articolo Tutto quello che c'è da sapere sulle eccezioni.

Conclusione

L'istruzione if è un'istruzione semplice ma fondamentale per PowerShell. Questa istruzione si usa spesso più volte in ogni script. L'obiettivo di questo articolo era approfondirne la conoscenza.