Condividi tramite

Tutto quello che volevi sapere sulla if dichiarazione

Analogamente a molti altri linguaggi, PowerShell include istruzioni per l'esecuzione condizionale del codice negli script. Una di queste istruzioni è l'istruzione If . Oggi si esaminerà in dettaglio uno dei comandi più fondamentali di PowerShell.

Annotazioni

La versione originale di questo articolo è apparsa nel blog scritto da @KevinMarquette. Il team di PowerShell ringrazia Kevin per aver condiviso questo contenuto con noi. Consultare il suo blog all'indirizzo PowerShellExplained.com.

Esecuzione condizionale

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

Istruzione if

Di seguito viene fornito un esempio di base della dichiarazione if:

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

La prima cosa che l'istruzione if esegue è valutare l'espressione tra parentesi. Se restituisce $true, esegue le istruzioni tra parentesi graffe. Se il valore fosse $false, avrebbe ignorato il blocco di istruzioni.

Nell'esempio precedente l'istruzione if stava semplicemente valutando la $condition variabile. Avrebbe $true ed eseguito il comando Write-Output all'interno del blocco di istruzioni.

In alcuni linguaggi è possibile inserire una singola riga di codice dopo l'istruzione if e viene eseguita. Questo non è il caso in PowerShell. Devi fornire un intero statement block con parentesi graffe per farlo funzionare correttamente.

Operatori di confronto

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

-eq per l'uguaglianza

-eq esegue un controllo di uguaglianza tra due valori per assicurarsi che siano uguali tra loro.

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

In questo esempio, sto prendendo un valore noto di 5 e confrontandolo con il mio $value per vedere se corrispondono.

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

È comune in altri linguaggi come C# usare == per l'uguaglianza (ad esempio: 5 == $value) ma non funziona con PowerShell. Un altro errore comune che gli utenti fanno consiste nell'usare il segno di uguale (ad esempio: 5 = $value) riservato per l'assegnazione di valori alle variabili. Posizionando il valore noto a sinistra, questo errore è più imbarazzante da fare.

Questo operatore (e altri) presenta alcune varianti.

  • -eq uguaglianza insensibile alla distinzione tra maiuscole e minuscole
  • -ieq uguaglianza senza distinzione tra maiuscole e minuscole
  • -ceq uguaglianza con distinzione tra maiuscole e minuscole

-ne non uguale

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

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

Usare questo per assicurarsi che l'azione venga eseguita solo se il valore non è 5. Un buon caso d'uso in cui sarebbe quello di verificare se un servizio era nello stato di esecuzione prima di provare ad avviarlo.

Variazioni:

  • -ne senza distinzione tra maiuscole e minuscole non uguale
  • -ine senza distinzione tra maiuscole e minuscole non uguale
  • -cne distinzione tra maiuscole e minuscole non uguale

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

-gt -ge -lt -le per maggiore o minore di

Questi operatori vengono usati durante il controllo per verificare se un valore è maggiore o minore di un altro valore. Il valore -gt -ge -lt -le rappresenta GreaterThan, GreaterThanOrEqual, LessThan e LessThanOrEqual.

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

Variazioni:

  • -gt Maggiore di
  • -igt maggiore di, senza distinzione tra maiuscole e minuscole
  • -cgt maggiore di, con distinzione tra maiuscole e minuscole
  • -ge maggiore o uguale a
  • -ige maggiore o uguale, senza distinzione tra maiuscole e minuscole
  • -cge maggiore o uguale, sensibile alle maiuscole
  • -lt Meno
  • -ilt minore di, non sensibile alle maiuscole e minuscole
  • -clt minore di, distinzione tra maiuscole e minuscole
  • -le minore o uguale a
  • -ile minore o uguale, senza distinzione tra lettere maiuscole e minuscole
  • -cle minore o uguale, con distinzione tra maiuscole e minuscole

Non so perché si dovrebbero usare opzioni case-sensitive e insensitive per questi operatori.

- Come corrispondenze con caratteri jolly

PowerShell ha una sintassi di pattern matching basata su caratteri jolly e può essere utilizzata con l'operatore -like. Questi pattern con caratteri jolly sono abbastanza semplici.

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

È importante sottolineare che il modello corrisponde all'intera stringa. Se è necessario trovare una corrispondenza tra qualcosa al centro della stringa, è necessario posizionare l'oggetto su entrambe le * estremità della stringa.

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

Variazioni:

  • -like metacarattere insensibile a maiuscole/minuscole
  • -ilike carattere jolly senza distinzione tra maiuscole e minuscole
  • -clike wildcard sensibile alle maiuscole
  • -notlike carattere jolly senza distinzione tra maiuscole e minuscole non corrispondenti
  • -inotlike metacarattere senza distinzione tra maiuscole e minuscole non corrisponde
  • -cnotlike caratteri jolly con distinzione tra maiuscole e minuscole non corrispondenti

-match espressione regolare

L'operatore -match consente di controllare una stringa per una corrispondenza basata su espressioni regolari. Usare questa opzione quando i pattern con caratteri jolly non offrono abbastanza flessibilità.

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

Un pattern regex corrisponde in qualsiasi punto della stringa di default. È quindi possibile specificare una sottostringa corrispondente come segue:

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

Regex è un linguaggio complesso a sé stante e vale la pena esaminarlo. Parlo più di -match e dei vari modi di usare regex in un altro articolo.

Variazioni:

  • -match regex senza distinzione tra maiuscole e minuscole
  • -imatch regex senza distinzione tra maiuscole e minuscole
  • -cmatch regex sensibile alla distinzione tra maiuscole e minuscole
  • -notmatch regex non corrispondente senza distinzione tra maiuscole e minuscole
  • -inotmatch regex senza distinzione tra maiuscole e minuscole non trovata corrispondenza
  • -cnotmatch regex con distinzione tra maiuscole e minuscole non corrisponde

-è di tipo

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

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

È possibile usarlo se si usano classi o si accettano vari oggetti sulla pipeline. È possibile avere un servizio o un nome di servizio come input. Controllare quindi se si dispone di un servizio e recuperare il servizio solo se si ha solo il nome.

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

Variazioni:

  • -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. Questa operazione viene gestita in modo leggermente diverso quando si lavora con una raccolta. Ogni elemento della raccolta viene valutato e l'operatore restituisce ogni valore che risulta in $true.

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

Questa operazione funziona ancora correttamente in un'istruzione if . Viene quindi restituito un valore dall'operatore , quindi 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. L'utilizzo di -ne con una raccolta restituisce $true se un elemento nella raccolta non corrisponde al vostro valore.

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

Questo può sembrare un trucco intelligente, ma abbiamo operatori -contains e -in che gestiscono questo in modo più efficiente. E -notcontains fa quello che ti aspetti.

-Contiene

L'operatore -contains controlla la raccolta per il tuo valore. Non appena trova una corrispondenza, restituisce $true.

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

Questo è il modo preferito per verificare se una raccolta contiene il tuo valore. Utilizzare Where-Object (o -eq) scorre l'intero elenco ogni volta e risulta notevolmente più lento.

Variazioni:

  • -contains corrispondenza senza distinzione tra maiuscole e minuscole
  • -icontains corrispondenza senza distinzione di maiuscole
  • -ccontains corrispondenza con distinzione tra maiuscole e minuscole
  • -notcontains senza distinzione tra maiuscole e minuscole non corrisponde
  • -inotcontains senza distinzione tra maiuscole e minuscole non corrispondenti
  • -cnotcontains distinzione tra maiuscole e minuscole non corrispondente

-in

L'operatore -in è simile all'operatore -contains, tranne per il fatto che la raccolta si trova sul lato destro.

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

Variazioni:

  • -in corrispondenza senza distinzione tra maiuscole e minuscole
  • -iin corrispondenza senza distinzione tra maiuscole e minuscole
  • -cin corrispondenza con distinzione tra maiuscole e minuscole
  • -notin senza distinzione tra maiuscole e minuscole non corrisponde
  • -inotin senza distinzione tra maiuscole e minuscole non corrispondenti
  • -cnotin distinzione tra maiuscole e minuscole non corrispondenti

Operatori logici

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

-Non

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 di cui si è parlato ha una variante in cui non è necessario usare l'operatore -not . Ma ci sono ancora volte che è utile.

! operator

È possibile usare ! come alias per -not.

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

È possibile vedere ! utilizzato di più da persone che provengono da linguaggi come C#. Preferisco digitarlo perché trovo difficile vedere quando si esaminano rapidamente gli script.

-E

È possibile combinare espressioni con l'operatore -and . Quando si esegue questa operazione, entrambi i lati devono essere $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 aggiunte parentesi aggiuntive per renderla più chiara in questo esempio, ma sono facoltative purché l'espressione sia semplice. Di seguito è riportato lo stesso esempio senza di essi.

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

La valutazione avviene da sinistra a destra. Se il primo elemento restituisce $false, esce presto e non effettua il confronto corretto. Questo è utile quando è necessario assicurarsi che un valore esista prima di usarlo. Ad esempio, Test-Path genera un errore se gli si assegna un $null percorso.

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

-o

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

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

Proprio come con l'operatore -and , la valutazione avviene da sinistra a destra. Ad eccezione del fatto che se la prima parte è $true, l'intera istruzione è $true e non elabora il resto dell'espressione.

Prendere nota anche del funzionamento della sintassi per questi operatori. Sono necessarie due espressioni separate. Ho visto che gli utenti cercano di fare qualcosa di simile a questo $value -eq 5 -or 6 senza rendersi conto del loro errore.

-xor esclusivo oppure

Questo è un po' insolito. -xor consente a una sola espressione di restituire $true. Pertanto, se entrambi gli elementi sono $false o entrambi gli elementi sono $true, l'intera espressione è $false. Un altro modo di vedere questa operazione è che l'espressione è vera solo quando i risultati dell'espressione sono differenti.

È raro che qualcuno possa mai usare questo operatore logico e non riesco a pensare a un buon esempio per perché lo userei mai.

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 E AND binario
  • -bor OR binario
  • -bxor OR esclusivo binario
  • -bnot NOT binario
  • -shl spostamento a sinistra
  • -shr spostamento a destra

Espressioni di PowerShell

È possibile usare PowerShell normale all'interno dell'istruzione di condizione.

if ( Test-Path -Path $Path )

Test-Path restituisce $true o $false quando viene eseguito. Questo vale anche per i comandi che restituiscono altri valori.

if ( Get-Process Notepad* )

Restituisce $true se esiste un processo restituito e $false in caso contrario. È perfettamente valido usare espressioni di pipeline o altre istruzioni di PowerShell come segue:

if ( Get-Process | where Name -EQ Notepad )

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

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

Verifica della presenza di $null

L'assenza di un risultato o di $null si valuta come $false nell'istruzione if. Quando si effettua un controllo specifico per $null, è una buona prassi posizionare l'oggetto $null sul lato sinistro.

if ( $null -eq $value )

Esistono diverse sfumature nella gestione dei valori $null in PowerShell. Se ti interessa approfondire, ho un articolo su tutto ciò che volevi sapere su $null.

Assegnazione di variabili all'interno della condizione

Ho quasi dimenticato di aggiungere questo uno fino a quando Prasoon Karunan V mi ha ricordato di esso.

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 un'espressione secondaria, viene passata alla pipeline.

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

Vedere in che modo l'assegnazione $first non ha output e l'assegnazione $second funziona? Quando un'assegnazione viene eseguita in un'istruzione if , viene eseguita esattamente come l'assegnazione $second precedente. Ecco un esempio pulito su come usarlo:

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

Se $process viene assegnato un valore, l'istruzione è $true e $process viene arrestata.

Assicurati di non confondere questo con -eq perché non si tratta di un controllo di uguaglianza. Si tratta di una funzionalità più oscura che la maggior parte delle persone non realizza funziona in questo modo.

Assegnazione di variabili dal blocco di istruzioni

È anche possibile usare il if blocco di istruzioni 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 . In questo esempio è possibile assegnare facilmente tali valori alla $discount variabile direttamente in ogni blocco di istruzioni. Non posso dire che uso questo con l'istruzione if spesso, ma ho un esempio in cui ho usato questo di recente.

Percorso di esecuzione alternativo

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

altro

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, verifica il $path per assicurarti che si tratti di un file. Se troviamo il file, lo spostiamo. In caso contrario, viene scritto un avviso. Questo tipo di logica di diramazione è molto comune.

Annidato se

Le if istruzioni e else accettano un blocco di script, in modo da poter inserire qualsiasi comando di PowerShell all'interno di essi, inclusa un'altra if istruzione. 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 si testa prima il percorso felice e quindi si esegue un'azione su di esso. In caso di esito negativo, eseguire un altro controllo e fornire informazioni più dettagliate all'utente.

Elseif

Non siamo limitati a un solo controllo condizionale. È possibile concatenare le istruzioni if e else insieme anziché 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 top if viene valutata per prima. Se è $false, viene spostato verso il basso fino al successivo elseif o else all'interno dell'elenco. L'ultima else è l'azione predefinita da eseguire se nessuna delle altre restituisce $true.

switch

A questo punto, devo menzionare la switch dichiarazione. Fornisce una sintassi alternativa per eseguire più confronti con un valore. Con , si specifica un'espressione switche il risultato viene confrontato con diversi valori. Se uno di questi valori corrisponde, viene eseguito il blocco di codice corrispondente. Esaminare questo esempio:

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

Esistono tre valori possibili che possono corrispondere a $itemType. In questo caso, corrisponde a Role. Ho usato un semplice esempio solo per darvi qualche esposizione all'operatore switch . Parlo di tutto ciò che hai mai voluto sapere sull'istruzione switch in un altro articolo.

Matrice inline

È disponibile una funzione denominata Invoke-SnowSql che avvia un eseguibile con diversi argomenti della riga di comando. Ecco un estratto da quella funzione in cui si costruisce l'array 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 $Debug variabili e $Path sono parametri nella funzione fornita dall'utente finale. Li valuti inline all'interno dell'inizializzazione della matrice. Se $Debug è true, questi valori rientrano $snowSqlParam nella posizione corretta. Lo stesso vale per la $Path variabile.

Semplificare operazioni complesse

È inevitabile che si verifichi una situazione in cui sono presenti troppi confronti da controllare e l'istruzione if scorre verso il lato destro dello 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
}

Possono essere difficili da leggere e che ti rendono più incline a commettere errori. Ci sono alcune cose che possiamo fare su questo.

Continuazione riga

In PowerShell sono disponibili alcuni operatori che consentono di eseguire il wrapping del comando alla riga successiva. Gli operatori -and logici e -or sono validi operatori da usare se si desidera 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
}

C'è ancora molto da fare, ma posizionare ogni pezzo sulla propria linea fa una grande differenza. In genere lo uso quando si ottengono più di due confronti o se è necessario scorrere verso destra per leggere una qualsiasi delle logiche.

Pre-calcolo dei risultati

È possibile escludere tale 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
}

Questo si sente molto più pulito dell'esempio precedente. Viene anche fornita l'opportunità di usare un nome di variabile che spieghi cosa è che si sta realmente controllando. Questo è anche e un esempio di codice autodocumentato che salva commenti non necessari.

Istruzioni if multiple

È possibile suddividere questa operazione in più istruzioni e controllarle una alla volta. In questo caso viene usato un flag o una variabile di rilevamento 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
}

È stato necessario invertire la logica per fare in modo che la logica del flag funzioni correttamente. Ogni valutazione è una singola if istruzione. Il vantaggio di questo è che quando si esegue il debug, è possibile indicare esattamente cosa sta facendo la logica. Sono riuscito a migliorare notevolmente la verbosità contemporaneamente.

L'ovvio svantaggio è che è molto più codice da scrivere. Il codice è più complesso da esaminare perché accetta una singola riga di logica ed esplode in 25 o più righe.

Uso delle funzioni

È anche possibile spostare tutta la logica di convalida in una funzione. Guarda quanto è pulito questo aspetto a prima vista.

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

È comunque necessario creare la funzione per eseguire la convalida, ma questo codice risulta molto più semplice da usare. Questo codice semplifica il test. Nei test è possibile simulare la chiamata a Test-ADDriveConfiguration e sono necessari solo due test per questa funzione. Uno in cui restituisce $true e uno in cui restituisce $false. Il test dell'altra funzione è più semplice perché è così piccolo.

Il corpo di quella funzione potrebbe ancora essere quella singola riga con cui abbiamo iniziato o la logica dettagliata che abbiamo usato nell'ultima sezione. Questo funziona bene per entrambi gli scenari e consente di modificare facilmente l'implementazione in un secondo momento.

Gestione degli errori

Un uso importante dell'istruzione if consiste nel verificare la presenza di condizioni di errore prima che si verifichino errori. Un buon esempio consiste nel verificare se esiste già una cartella prima di provare a crearla.

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

Mi piace dire che se si prevede che si verifichi un'eccezione, allora non è davvero un'eccezione. Controllare quindi i valori e convalidare le condizioni in cui è possibile.

Se vuoi approfondire la gestione effettiva delle eccezioni, ho un articolo su tutto ciò che vuoi sapere sulle eccezioni.

Parole finali

L'istruzione if è un'istruzione così semplice, ma è una parte fondamentale di PowerShell. Questa operazione viene usata più volte in quasi tutti gli script scritti. Spero che tu abbia una comprensione migliore di quella che avevi prima.

  • Last updated on