Alles wat u wilde weten over de if instructie

Net als in veel andere talen bevat PowerShell instructies voor het voorwaardelijk uitvoeren van code in uw scripts. Een van deze beweringen is de If-instructie . Vandaag gaan we dieper in op een van de meest fundamentele opdrachten in PowerShell.

Notitie

De oorspronkelijke versie van dit artikel verscheen op het blog geschreven door @KevinMarquette. Het PowerShell-team bedankt Kevin voor het delen van deze inhoud met ons. Bekijk zijn blog op PowerShellExplained.com.

Voorwaardelijke uitvoering

Uw scripts moeten vaak beslissingen nemen en verschillende logica uitvoeren op basis van deze beslissingen. Dit bedoel ik met voorwaardelijke uitvoering. U hebt één instructie of waarde die u wilt evalueren en voert vervolgens een andere codesectie uit op basis van die evaluatie. Dit is precies wat de if verklaring doet.

De if instructie

Hier volgt een eenvoudig voorbeeld van de if instructie:

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

Het eerste wat de if instructie doet, is het evalueren van de expressie tussen haakjes. Als dit wordt geëvalueerd $true, wordt de scriptblock accolade uitgevoerd. Als de waarde was $false, wordt dat scriptblok overgeslagen.

In het vorige voorbeeld is de if instructie net bezig met het evalueren van de $condition variabele. Het was $true en zou de Write-Output opdracht in de scriptblock hebben uitgevoerd.

In sommige talen kunt u één regel code plaatsen na de if instructie en deze wordt uitgevoerd. Dat is niet het geval in PowerShell. U moet een volledige scriptblock accolade opgeven om deze correct te laten werken.

Vergelijkingsoperatoren

Het meest voorkomende gebruik van de if instructie is het vergelijken van twee items met elkaar. PowerShell heeft speciale operators voor verschillende vergelijkingsscenario's. Wanneer u een vergelijkingsoperator gebruikt, wordt de waarde aan de linkerkant vergeleken met de waarde aan de rechterkant.

-eq voor gelijkheid

Er -eq wordt een gelijkheidscontrole tussen twee waarden gecontroleerd om ervoor te zorgen dat ze gelijk zijn aan elkaar.

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

In dit voorbeeld neem ik een bekende waarde van 5 en vergelijk ik deze met mijn $value om te zien of ze overeenkomen.

Een mogelijke use-case is om de status van een waarde te controleren voordat u actie onderneemt. U kunt een service krijgen en controleren of de status werd uitgevoerd voordat u deze aanriep Restart-Service .

Het is gebruikelijk in andere talen zoals C# om te gebruiken == voor gelijkheid (bijvoorbeeld 5 == $value) maar dat werkt niet met PowerShell. Een andere veelvoorkomende fout die mensen maken, is het gebruik van het gelijkteken (bijvoorbeeld: 5 = $value) dat is gereserveerd voor het toewijzen van waarden aan variabelen. Door uw bekende waarde aan de linkerkant te plaatsen, maakt het die fout lastiger om te maken.

Deze operator (en andere) heeft een paar variaties.

• -eq hoofdlettergevoelige gelijkheid
• -ieq hoofdlettergevoelige gelijkheid
• -ceq casegevoelig gelijkheid

-ne niet gelijk aan

Veel operators hebben een gerelateerde operator die controleert op het tegenovergestelde resultaat. -ne controleert of de waarden niet gelijk zijn aan elkaar.

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

Gebruik deze optie om ervoor te zorgen dat de actie alleen wordt uitgevoerd als de waarde niet 5is. Een goede gebruikssituatie waarbij moet worden gecontroleerd of een service de status Actief heeft voordat u deze probeert te starten.

Variaties:

• -ne hoofdlettergevoelig niet gelijk aan
• -ine hoofdlettergevoelig niet gelijk aan
• -cne casegevoelig not equal

Dit zijn inverse variaties van -eq. Ik groepeer deze typen wanneer ik variaties voor andere operators vermeld.

-gt -ge -lt -le voor groter dan of kleiner dan

Deze operators worden gebruikt bij het controleren of een waarde groter of kleiner is dan een andere waarde. De -gt -ge -lt -le stand voor GreaterThan, GreaterThanOrEqual, LessThan en LessThanOrEqual.

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

Variaties:

• -gt groter dan
• -igt groter dan, niet hoofdlettergevoelig
• -cgt groter dan, hoofdlettergevoelig
• -ge groter dan of gelijk aan
• -ige groter dan of gelijk, niet hoofdlettergevoelig
• -cge groter dan of gelijk aan hoofdlettergevoelig
• -lt kleiner dan
• -ilt kleiner dan, niet hoofdlettergevoelig
• -clt kleiner dan, hoofdlettergevoelig
• -le kleiner dan of gelijk aan
• -ile kleiner dan of gelijk aan, niet hoofdlettergevoelig
• -cle kleiner dan of gelijk aan, hoofdlettergevoelig

Ik weet niet waarom u hoofdlettergevoelige en niet-gevoelige opties voor deze operators zou gebruiken.

-like jokertekenovereenkomsten

PowerShell heeft een eigen op jokertekens gebaseerde patroonsyntaxis en u kunt dit gebruiken met de -like operator. Deze jokertekenpatronen zijn vrij eenvoudig.

• ? komt overeen met één teken
• * komt overeen met een willekeurig aantal tekens

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

Het is belangrijk om aan te geven dat het patroon overeenkomt met de hele tekenreeks. Als u iets in het midden van de tekenreeks wilt vergelijken, moet u de * beide uiteinden van de tekenreeks plaatsen.

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

Variaties:

• -like niet hoofdlettergevoelig jokerteken
• -ilike niet hoofdlettergevoelig jokerteken
• -clike casegevoelig jokerteken
• -notlike niet-hoofdlettergevoelig jokerteken niet overeenkomen
• -inotlike niet-hoofdlettergevoelig jokerteken niet overeenkomen
• -cnotlike niet overeenkomend met casegevoelig jokerteken

-match regular expression

Met de -match operator kunt u een tekenreeks controleren op een op reguliere expressie gebaseerde overeenkomst. Gebruik dit als de jokertekenpatronen niet flexibel genoeg zijn voor u.

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

Een regex-patroon komt standaard overal in de tekenreeks overeen. U kunt dus een subtekenreeks opgeven die u als volgt wilt vergelijken:

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

Regex is een complexe taal van eigen en het bekijken waard. Ik heb het over -match en de vele manieren om regex in een ander artikel te gebruiken.

Variaties:

• -match hoofdlettergevoelige regex
• -imatch hoofdlettergevoelige regex
• -cmatch casegevoelig regex
• -notmatch niet-hoofdlettergevoelige regex komt niet overeen
• -inotmatch niet-hoofdlettergevoelige regex komt niet overeen
• -cnotmatch casegevoelig regex not matched

-is van het type

U kunt het type waarde controleren met de -is operator.

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

U kunt dit gebruiken als u met klassen werkt of verschillende objecten via de pijplijn accepteert. U kunt een service- of servicenaam als invoer hebben. Controleer vervolgens of u een service hebt en de service ophaalt als u alleen de naam hebt.

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

Variaties:

• -is van het type
• -isnot niet van het type

Verzamelingsoperators

Wanneer u de vorige operatoren met één waarde gebruikt, is $true het resultaat of $false. Dit wordt iets anders verwerkt wanneer u met een verzameling werkt. Elk item in de verzameling wordt geëvalueerd en de operator retourneert elke waarde die wordt geëvalueerd $true.

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

Dit werkt nog steeds correct in een if instructie. Dus een waarde wordt geretourneerd door uw operator, dan is $truede hele instructie .

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

Er is een kleine val die me verbergt in de details die ik moet wijzen. Wanneer u de -ne operator op deze manier gebruikt, is het eenvoudig om per ongeluk naar de logica te kijken. Het gebruik -ne met een verzameling retourneert $true als een item in de verzameling niet overeenkomt met uw waarde.

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

Dit lijkt misschien een slimme truc, maar we hebben operators -contains en -in die dit efficiënter verwerken. En -notcontains doet wat je verwacht.

-contains

De -contains operator controleert de verzameling op uw waarde. Zodra er een overeenkomst wordt gevonden, wordt deze geretourneerd $true.

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

Dit is de voorkeursmethode om te zien of een verzameling uw waarde bevat. Als Where-Object u (of -eq) gebruikt, wordt de hele lijst elke keer stapsgewijs weergegeven en is deze aanzienlijk langzamer.

Variaties:

• -contains hoofdlettergevoelige overeenkomst
• -icontains hoofdlettergevoelige overeenkomst
• -ccontains casegevoelig match
• -notcontains niet-hoofdlettergevoelig niet overeenkomend
• -inotcontains niet-hoofdlettergevoelig niet overeenkomend
• -cnotcontains hoofdlettergevoelig niet overeenkomend

-in

De -in operator is net als de -contains operator, behalve dat de verzameling zich aan de rechterkant bevindt.

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

Variaties:

• -in hoofdlettergevoelige overeenkomst
• -iin hoofdlettergevoelige overeenkomst
• -cin casegevoelig match
• -notin niet-hoofdlettergevoelig niet overeenkomend
• -inotin niet-hoofdlettergevoelig niet overeenkomend
• -cnotin hoofdlettergevoelig niet overeenkomend

Logische operators

Logische operators worden gebruikt om andere expressies om te keren of te combineren.

-niet

De -not operator spiegelt een expressie van $false naar $true of van $true naar $false. Hier volgt een voorbeeld waarin we een actie willen uitvoeren wanneer Test-Path dat het is $false.

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

De meeste operators waarover we hebben gesproken, hebben een variatie waarbij u de -not operator niet hoeft te gebruiken. Maar er zijn nog steeds tijden dat het nuttig is.

! operator

U kunt deze gebruiken ! als alias voor -not.

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

Mogelijk ziet ! u meer gebruikt door personen die afkomstig zijn uit andere talen, zoals C#. Ik typ het liever omdat ik het moeilijk vind om te zien wanneer ik mijn scripts snel bekijk.

-en

U kunt expressies combineren met de -and operator. Als u dat doet, moeten beide zijden ervoor zorgen $true dat de hele expressie moet zijn $true.

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

In dat voorbeeld $age moet 13 of ouder zijn voor de linkerkant en kleiner dan 55 voor de rechterkant. Ik heb extra haakjes toegevoegd om het in dat voorbeeld duidelijker te maken, maar ze zijn optioneel zolang de expressie eenvoudig is. Hier volgt hetzelfde voorbeeld zonder deze.

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

Evaluatie vindt plaats van links naar rechts. Als het eerste item wordt geëvalueerd $false, wordt het vroeg afgesloten en wordt de juiste vergelijking niet uitgevoerd. Dit is handig wanneer u ervoor moet zorgen dat er een waarde bestaat voordat u deze gebruikt. Genereert bijvoorbeeld Test-Path een fout als u het pad $null opgeeft.

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

-of

Hiermee -or kunt u twee expressies opgeven en retourneren als een van deze expressies $true is $true.

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

Net als bij de -and operator vindt de evaluatie plaats van links naar rechts. Behalve dat als het eerste deel is, dan is $true$true de hele instructie en verwerkt de rest van de expressie niet.

Noteer ook hoe de syntaxis werkt voor deze operators. U hebt twee afzonderlijke expressies nodig. Ik heb gezien dat gebruikers zoiets $value -eq 5 -or 6 proberen te doen zonder hun fout te realiseren.

-xor exclusief of

Deze is een beetje ongebruikelijk. -xor staat slechts één expressie toe om te $trueevalueren. Dus als beide items zijn $false of beide items zijn $true, is $falsede hele expressie . Een andere manier om dit te bekijken, is de expressie alleen $true wanneer de resultaten van de expressie anders zijn.

Het is zeldzaam dat iemand deze logische operator ooit zou gebruiken en ik kan geen goed voorbeeld bedenken waarom ik het ooit zou gebruiken.

Bitsgewijze operatoren

Bitwise-operators voeren berekeningen uit op de bits binnen de waarden en produceren een nieuwe waarde als resultaat. Het onderwijzen van bitwise operators valt buiten het bereik van dit artikel, maar hier is de lijst met de operators.

• -band binair EN
• -bor binair OF
• -bxor binair exclusief OR
• -bnot binair NOT
• -shl shift naar links
• -shr naar rechts verschuiven

PowerShell-expressies

We kunnen normale PowerShell in de voorwaarde-instructie gebruiken.

if ( Test-Path -Path $Path )

Test-Path retourneert $true of $false wanneer deze wordt uitgevoerd. Dit geldt ook voor opdrachten die andere waarden retourneren.

if ( Get-Process Notepad* )

Het evalueert of $true er een geretourneerd proces is en $false of er iets is. Het is perfect geldig om pijplijnexpressies of andere PowerShell-instructies als volgt te gebruiken:

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

Deze expressies kunnen met elkaar worden gecombineerd met de -and operatoren, -or maar mogelijk moet u haakjes gebruiken om ze in subexpressies op te splitsen.

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

Controleren op $null

Het hebben van een resultaat of een $null waarde die in de if instructie wordt geëvalueerd$false. Wanneer u specifiek controleert $null, is het een best practice om de $null linkse kant te plaatsen.

if ( $null -eq $value )

Er zijn nogal wat nuances bij het omgaan met $null waarden in PowerShell. Als je geïnteresseerd bent in dieper duiken, heb ik een artikel over alles wat je wilde weten over $null.

Variabele toewijzing binnen de voorwaarde

Ik ben bijna vergeten deze toe te voegen tot Prasoon Karunan V me eraan herinnerde.

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

Normaal gesproken wordt de waarde niet doorgegeven aan de pijplijn of console wanneer u een waarde toewijst aan een variabele. Wanneer u een variabeletoewijzing uitvoert in een subexpressie, wordt deze doorgegeven aan de pijplijn.

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

Ziet u hoe de $first toewijzing geen uitvoer heeft en wat de $second toewijzing doet? Wanneer een opdracht wordt uitgevoerd in een if instructie, wordt deze uitgevoerd op dezelfde wijze als de $second bovenstaande opdracht. Hier volgt een schoon voorbeeld van hoe u deze kunt gebruiken:

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

Als $process er een waarde wordt toegewezen, wordt de instructie gestopt $true$process .

Zorg ervoor dat u dit -eq niet in de war brengt, omdat dit geen gelijkheidscontrole is. Dit is een meer verborgen functie die de meeste mensen niet op deze manier realiseren.

Variabele toewijzing vanuit het scriptblok

U kunt ook de if instructiescriptblock gebruiken om een waarde toe te wijzen aan een variabele.

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

Elk scriptblok schrijft de resultaten van de opdrachten, of de waarde, als uitvoer. We kunnen het resultaat van de if instructie toewijzen aan de $discount variabele. In dat voorbeeld kunnen deze waarden net zo eenvoudig rechtstreeks in elk scriptblok aan de $discount variabele worden toegewezen. Ik kan niet zeggen dat ik dit vaak met de if verklaring gebruik, maar ik heb wel een voorbeeld waarin ik dit onlangs heb gebruikt.

Alternatief uitvoeringspad

Met if de instructie kunt u een actie opgeven voor niet alleen wanneer de instructie is $true, maar ook voor wanneer dit het is $false. Dit is waar de else verklaring in het spel komt.

else

De else instructie is altijd het laatste deel van de if instructie wanneer deze wordt gebruikt.

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 dit voorbeeld controleren we of $path het een bestand is. Als we het bestand vinden, verplaatsen we het. Zo niet, dan schrijven we een waarschuwing. Dit type vertakkingslogica is heel gebruikelijk.

Genest als

De if instructies else nemen een scriptblok, zodat we elke PowerShell-opdracht erin kunnen plaatsen, inclusief een andere if instructie. Hierdoor kunt u gebruikmaken van veel gecompliceerdere logica.

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 dit voorbeeld testen we eerst het gelukkige pad en nemen we er vervolgens actie op. Als dat mislukt, voeren we nog een controle uit en geven we meer gedetailleerde informatie aan de gebruiker.

elseif

We zijn niet beperkt tot slechts één voorwaardelijke controle. We kunnen deze koppelen en else samenbrengen if in plaats van ze te nesten met behulp van de elseif instructie.

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."
}

De uitvoering vindt plaats van boven naar beneden. De bovenste if instructie wordt eerst geëvalueerd. Als dat het is $false, gaat deze omlaag naar de volgende elseif of else in de lijst. Dat laatste else is de standaardactie die moet worden uitgevoerd als geen van de andere retourneert $true.

schakelen

Op dit punt moet ik de switch verklaring vermelden. Het biedt een alternatieve syntaxis voor het uitvoeren van meerdere vergelijkingen met een waarde. Met de switchexpressie geeft u een expressie op en dat resultaat wordt vergeleken met verschillende waarden. Als een van deze waarden overeenkomt, wordt het overeenkomende codeblok uitgevoerd. Bekijk dit voorbeeld:

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

Er zijn drie mogelijke waarden die overeenkomen met de $itemType. In dit geval komt het overeen met Role. Ik heb een eenvoudig voorbeeld gebruikt om u wat blootstelling te geven aan de switch operator. Ik heb meer gesproken over alles wat je ooit wilde weten over de switch-instructie in een ander artikel.

Matrix inline

Ik heb een functie met de naam Invoke-SnowSql waarmee een uitvoerbaar bestand met verschillende opdrachtregelargumenten wordt gestart. Hier volgt een clip van die functie waarin ik de matrix met argumenten maak.

$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
    }
)

De $Debug en $Path variabelen zijn parameters voor de functie die door de eindgebruiker worden verstrekt. Ik evalueer ze inline in de initialisatie van mijn matrix. Als $Debug waar is, vallen deze waarden in de $snowSqlParam juiste plaats. Hetzelfde geldt voor de $Path variabele.

Complexe bewerkingen vereenvoudigen

Het is onvermijdelijk dat u een situatie tegenkomt die veel te veel vergelijkingen heeft om te controleren en uw If instructie naar de rechterkant van het scherm schuift.

$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
}

Ze kunnen moeilijk te lezen zijn en dat maakt u gevoeliger om fouten te maken. Er zijn een paar dingen die we hierover kunnen doen.

Lijnvervolging

Er zijn enkele operators in PowerShell waarmee u de opdracht naar de volgende regel kunt teruglopen. De logische operators en -or zijn goede operators -and die u kunt gebruiken als u uw expressie in meerdere regels wilt opsplitsen.

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

Er is nog steeds veel aan de hand, maar het plaatsen van elk stuk op een eigen lijn maakt een groot verschil. Ik gebruik dit over het algemeen als ik meer dan twee vergelijkingen krijg of als ik naar rechts moet schuiven om een van de logica te lezen.

Resultaten vooraf berekenen

We kunnen deze instructie uit de if instructie halen en alleen het resultaat controleren.

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

if ( $needsSecureHomeDrive )
{
    # Do Something
}

Dit voelt gewoon veel schoner aan dan in het vorige voorbeeld. U krijgt ook de mogelijkheid om een variabelenaam te gebruiken waarin wordt uitgelegd wat u echt controleert. Dit is ook een voorbeeld van zelfdocumenterende code waarmee onnodige opmerkingen worden opgeslagen.

Meerdere if-instructies

We kunnen dit opsplitsen in meerdere instructies en ze één voor één controleren. In dit geval gebruiken we een vlag of een traceringsvariabele om de resultaten te combineren.

$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
}

Ik moest de logica omkeren om de vlaglogica correct te laten werken. Elke evaluatie is een afzonderlijke if instructie. Het voordeel hiervan is dat wanneer u foutopsporing uitvoert, u precies kunt zien wat de logica doet. Ik kon tegelijkertijd veel betere uitgebreidheid toevoegen.

Het voor de hand liggende nadeel is dat het zoveel meer code is om te schrijven. De code is complexer om te kijken naarmate er één regel logica nodig is en deze in 25 of meer regels explodeert.

Functies gebruiken

We kunnen ook al die validatielogica naar een functie verplaatsen. Kijk hoe schoon dit eruitziet in een oogopslag.

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

U moet nog steeds de functie maken om de validatie uit te voeren, maar deze code is veel eenvoudiger om mee te werken. Hierdoor is deze code eenvoudiger te testen. In uw tests kunt u de aanroep naar Test-ADDriveConfiguration en u hebt slechts twee tests nodig voor deze functie. Een waar het wordt geretourneerd $true en een waar het retourneert $false. Het testen van de andere functie is eenvoudiger omdat deze zo klein is.

De hoofdtekst van die functie kan nog steeds die one-liner zijn waarmee we begonnen of de ontplofte logica die we in de laatste sectie hebben gebruikt. Dit werkt goed voor beide scenario's en stelt u in staat om deze implementatie later eenvoudig te wijzigen.

Foutafhandeling

Een belangrijk gebruik van de if instructie is om te controleren op foutvoorwaarden voordat u fouten tegenloopt. Een goed voorbeeld is om te controleren of er al een map bestaat voordat u deze probeert te maken.

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

Ik wil zeggen dat als je verwacht dat er een uitzondering optreedt, het niet echt een uitzondering is. Controleer dus uw waarden en valideer waar mogelijk uw voorwaarden.

Als u wat meer wilt weten over de daadwerkelijke verwerking van uitzonderingen, heb ik een artikel over alles wat u ooit wilde weten over uitzonderingen.

Laatste woorden

De if instructie is zo'n eenvoudige instructie, maar is een fundamenteel onderdeel van PowerShell. U zult dit meerdere keren gebruiken in bijna elk script dat u schrijft. Ik hoop dat je een beter begrip hebt dan je eerder had.