Alles wat u wilde weten over de `if` statement

2025-03-31

Net als in veel andere talen bevat PowerShell instructies voor het voorwaardelijk uitvoeren van code in uw scripts. Een van deze uitspraken 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 de 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 ander codegedeelte 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 de uitdrukking tussen haakjes evalueren. Als het gelijk is aan $true, dan wordt de scriptblock in de accolades uitgevoerd. Als de waarde is $false, wordt dat scriptblok overgeslagen.

In het vorige voorbeeld evalueerde de if-instructie uitsluitend de variabele $condition. Het was $true en zou de Write-Output opdracht in het scriptblok 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 met accolades opgeven om het correct te laten functioneren.

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

De -eq voert een gelijkheidscontrole uit tussen twee waarden 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 er een actie op uitvoert. U kunt een service verkrijgen en controleren of de status actief is voordat u Restart-Service aanriep.

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 onhandiger om te maken.

Deze operator (en andere) heeft enkele variaties.

-eq hoofdletterongevoelige gelijkheid
-ieq hoofdletterongevoelige gelijkheid
-ceq hoofdlettergevoelige gelijkheid

-ne niet gelijk aan

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

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

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

Variaties:

-ne niet gelijk aan, niet hoofdlettergevoelig
-ine niet gelijk aan niet hoofdlettergevoelig
-cne hoofdlettergevoelig niet gelijk aan

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 staat 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 minder dan niet-hoofdlettergevoelig
-clt kleiner dan en hoofdlettergevoelig
-le kleiner dan of gelijk aan
-ile kleiner dan of gelijk, niet hoofdlettergevoelig
-cle kleiner dan of gelijk aan, hoofdlettergevoelig

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

overeenkomsten met jokertekens

PowerShell heeft zijn eigen syntaxis voor patroonmatching met jokertekens en u kunt deze syntaxis gebruiken met de operator -like. Deze jokertekenpatronen zijn redelijk eenvoudig.

? komt overeen met een willekeurig 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 * aan beide uiteinden van de tekenreeks plaatsen.

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

Varianten:

-like niet hoofdlettergevoelig jokerteken
-ilike niet hoofdlettergevoelig jokerteken
-clike hoofdlettergevoelig jokerteken
-notlike komt niet overeen met de niet-hoofdlettergevoelige wildcard
-inotlike hoofdletterongevoelig jokerteken komt niet overeen
-cnotlike hoofdlettergevoelig wildcard komt niet overeen

-match reguliere expressie

Met de operator -match kunt u een tekenreeks controleren op een overeenkomst op basis van reguliere expressies. Gebruik deze optie wanneer de jokertekenpatronen niet flexibel genoeg voor u zijn.

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

Een regex-patroon vindt standaard overal in de tekenreeks overeenkomsten. U kunt dus een subtekenreeks opgeven die u als volgt wilt laten overeenkomen:

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

Regex is een complexe taal op zichzelf en de moeite waard om te bestuderen. Ik praat meer over -match en de vele manieren om regex- in een ander artikel te gebruiken.

variaties:

-match hoofdlettergevoelige regex
-imatch hoofdlettergevoelige regex
-cmatch hoofdlettergevoelige regex
-notmatch regex die niet-hoofdlettergevoelig is komt niet overeen
-inotmatch case-insensitive regex geen match gevonden
-cnotmatch hoofdlettergevoelige regex komt niet overeen

-is van het type

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

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 een servicenaam als invoer hebben. Controleer vervolgens of je een service hebt en haal de service op als je alleen de naam hebt.

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

Variaties:

-is van type
-isnot niet van dit type

Operatoren voor verzameling

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

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

Dit werkt nog steeds correct in een if verklaring. Er wordt dus een waarde geretourneerd door uw operator en de hele instructie wordt $true.

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

Er is een kleine valkuil verborgen in de details die ik hier moet aanwijzen. Wanneer u de -ne-operator op deze manier gebruikt, kunt u de logica gemakkelijk verkeerd begrijpen. Als u -ne gebruikt met een verzameling, wordt $true geretourneerd als een item in de verzameling niet overeenkomt met uw waarde.

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

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

-bevat

Operator -contains controleert de verzameling op de door u opgegeven waarde. Zodra er een overeenkomst wordt gevonden, wordt $truegeretourneerd.

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

Dit is de voorkeurswijze om te zien of een verzameling uw waarde bevat. Het gebruik van Where-Object (of -eq) doorloopt de hele lijst elke keer, waardoor het aanzienlijk langzamer is.

Variaties:

-contains hoofdletterongevoelige overeenkomst
-icontains hoofdletterongevoelige overeenkomst
-ccontains hoofdlettergevoelige overeenkomst
-notcontains komt niet overeen, ongeacht hoofdlettergebruik
-inotcontains komt niet overeen en is niet hoofdlettergevoelig
-cnotcontains hoofdlettergevoelig niet overeenkomen

-in

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

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

Variaties:

-in hoofdletterongevoelige overeenkomst
-iin hoofdletterongevoelige overeenkomst
-cin hoofdlettergevoelige overeenkomst
-notin niet hoofdlettergevoelig en komt niet overeen
-inotin niet hoofdlettergevoelig en niet overeenkomend
-cnotin hoofdlettergevoelig komt niet overeen

Logische operatoren

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

-niet

Met de operator -not wordt een expressie omgekeerd van $false naar $true of van $true naar $false. Hier volgt een voorbeeld waarin we een actie willen uitvoeren wanneer Test-Path is $false.

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

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

! bediener

U kunt ! gebruiken als alias voor -not.

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

Mogelijk ziet u ! meer gebruikt door personen die afkomstig zijn uit een andere taal, 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 operator -and. Als u dat doet, moeten beide zijden $true zijn zodat de gehele uitdrukking $trueis.

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

In dat voorbeeld moet $age 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 evalueert tot $false, wordt het voortijdig beëindigd en wordt de juiste vergelijking niet uitgevoerd. Dit is handig wanneer u ervoor moet zorgen dat er een waarde bestaat voordat u deze gebruikt. Test-Path genereert bijvoorbeeld een fout als u deze een $null pad geeft.

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

-of

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

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

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

Noteer ook hoe de syntaxis werkt voor deze operators. U hebt twee afzonderlijke expressies nodig. Ik heb gezien dat gebruikers iets als dit $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 uitdrukking toe om te evalueren tot $true. Dus als beide items zijn $false of beide items $truezijn, is de hele expressie $false. Een andere manier om dit te bekijken, is dat de uitdrukking alleen $true is wanneer de resultaten van de uitdrukking 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 bewerkingen valt buiten de scope van dit artikel, maar hier is de lijst van bitwise bewerkingen.

-band binair AND
-bor binair OR
-bxor binaire exclusieve OR
-bnot binair NIET
-shl naar links verplaatsen
-shr naar rechts verschuiven

PowerShell-expressies

We kunnen normale PowerShell in de voorwaardeverklaring 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 resulteert in $true als er een geretourneerd proces is en in $false als dat niet zo 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 operatoren -and en -or, maar mogelijk moet u haakjes gebruiken om ze op te splitsen in subexpressies.

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

Controleren op $null

Het hebben van geen resultaat of een $null-waarde evalueert naar $false in de if-instructie. Wanneer u specifiek op $nullcontroleert, is het een best practice om de $null aan de linkerkant 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 deze bijna vergeten toe te voegen tot Prasoon Karunan V me eraan herinnerd.

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

Zie hoe de $first opdracht geen uitvoer heeft terwijl de $second opdracht dat wel heeft? Wanneer een opdracht wordt uitgevoerd in een if-instructie, wordt deze net als de bovenstaande $second-toewijzing uitgevoerd. Hier volgt een schoon voorbeeld van hoe u deze kunt gebruiken:

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

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

Zorg ervoor dat u dit niet verwar met -eq omdat dit geen gelijkheidscontrole is. Dit is een onbekende functie die de meeste mensen niet beseffen dat op deze manier werkt.

Variabele toewijzing vanuit het scriptblok

U kunt ook het scriptblok voor de if instructie 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 gebruik met de if verklaring, maar ik heb wel een voorbeeld waarin ik dit onlangs heb gebruikt.

Alternatief uitvoeringspad

Met de instructie if kunt u een actie opgeven voor niet alleen wanneer de instructie is $true, maar ook voor wanneer deze is $false. Hier komt de else verklaring aan de bod.

anders

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 de $path om te controleren of 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- en else-instructies nemen een scriptblok, zodat we elke PowerShell-opdracht erin kunnen plaatsen, inclusief een andere if-instructie. Hierdoor kunt u veel complexere logica gebruiken.

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 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 if- en else-instructies samenvoegen 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 belangrijkste if instructie wordt eerst geëvalueerd. Als dat $falseis, gaat deze omlaag naar de volgende elseif of else in de lijst. Die laatste else is de standaardactie die moet worden uitgevoerd als geen van de andere acties $trueretourneert.

schakelaar

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 switchgeeft 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 je kennis te laten maken met de switch-operator. Ik vertel meer over alles wat je ooit wilde weten over de switch-statement in een ander artikel.

Array 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 variabelen $Debug en $Path zijn parameters voor de functie die door de eindgebruiker wordt geleverd. Ik evalueer ze direct tijdens de initialisatie van mijn array. Als $Debug waar is, vallen deze waarden op de juiste plaats in de $snowSqlParam. Hetzelfde geldt voor de variabele $Path.

Complexe bewerkingen vereenvoudigen

Het is onvermijdelijk dat u een situatie tegenkomt waarin er veel te veel vergelijkingen zijn om na te gaan en uw if-instructie verdwijnt van de rechterkant van het scherm.

$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 waardoor u gevoeliger bent voor fouten. Er zijn een paar dingen die we daar aan kunnen doen.

Regelovername

Er zijn enkele operators in PowerShell waarmee u de opdracht naar de volgende regel kunt verpakken. De logische operators -and en -or zijn goede operators die u kunt gebruiken als u de 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 die 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 het is dat u echt controleert. Dit is ook en een voorbeeld van zelfdocumenterende code waarmee onnodige opmerkingen worden opgeslagen.

Meerdere if-statements

We kunnen dit opsplitsen in meerdere uitspraken en ze één voor één controleren. In dit geval gebruiken we een vlag of een trackingvariabele 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-verklaring. Het voordeel hiervan is dat wanneer u foutopsporing uitvoert, u precies kunt zien wat de logica doet. Ik kon tegelijkertijd een veel betere manier van woordrijkheid toevoegen.

Het voor de hand liggende nadeel is dat het zoveel meer code is om te schrijven. De code is gecompliceerder omdat een enkele logische regel wordt uitgewerkt tot 25 of meer regels.

Functies gebruiken

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

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 gemakkelijker te gebruiken. Hierdoor is deze code eenvoudiger te testen. In uw tests kunt u de aanroep naar Test-ADDriveConfiguration mocken en u hebt slechts twee tests voor deze functie nodig. Een waar het $true retourneert en een waar het $falseretourneert. Het testen van de andere functie is eenvoudiger omdat deze zo klein is.

De hoofdtekst van die functie kan nog steeds die ene regel zijn waarmee we begonnen, of de uitgebreide 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 foutcondities voordat u op fouten stuit. 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 plaatsvindt, het niet echt een uitzondering is. Controleer dus uw waarden en valideer uw voorwaarden waar u kunt.

Als je wat meer wilt ingaan op de daadwerkelijke verwerking van uitzonderingen, heb ik een artikel over alles wat je 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.

Delen via

Alles wat u wilde weten over de if statement

Voorwaardelijke uitvoering

De if-instructie

Vergelijkingsoperatoren

-eq voor gelijkheid

-ne niet gelijk aan

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

overeenkomsten met jokertekens

-match reguliere expressie

-is van het type

Operatoren voor verzameling

-bevat

-in

Logische operatoren

-niet

! bediener

-en

-of

-xor exclusief of

Bitsgewijze operatoren

PowerShell-expressies

Controleren op $null

Variabele toewijzing binnen de voorwaarde

Variabele toewijzing vanuit het scriptblok

Alternatief uitvoeringspad

anders

Genest als

elseif

schakelaar

Array inline

Complexe bewerkingen vereenvoudigen

Regelovername

Resultaten vooraf berekenen

Meerdere if-statements

Functies gebruiken

Foutafhandeling

Laatste woorden

Aanvullende resources

Alles wat u wilde weten over de `if` statement

De `if`-instructie