over_Vergelijkingsoperatoren

Korte beschrijving

De vergelijkingsoperatoren in PowerShell kunnen twee waarden vergelijken of elementen van een verzameling filteren op basis van een invoerwaarde.

Lange beschrijving

Met vergelijkingsoperatoren kunt u waarden vergelijken of waarden zoeken die overeenkomen met opgegeven patronen. PowerShell bevat de volgende vergelijkingsoperatoren:

gelijkheid

• -eq, -ieq, -ceq - is gelijk aan
• -ne, -ine, -cne - niet gelijk aan
• -gt, -igt, -cgt - groter dan
• -ge, -ige, -cge - groter dan of gelijk aan
• -lt, -ilt, -clt - kleiner dan
• -le, -ile, -cle - kleiner dan of gelijk aan

overeenkomende

• -like, -ilike, -clike - string komt overeen met wildcard patroon
• -notlike, -inotlike, -cnotlike - tekst komt niet overeen met jokerpatroon
• -match, -imatch, -cmatch - tekenreeks komt overeen met regex-patroon
• -notmatch, -inotmatch, -cnotmatch - tekenreeks komt niet overeen met regex-patroon

Vervangende-onderdeel

• -replace, , -ireplace - -creplacezoekt en vervangt tekenreeksen die overeenkomen met een regex-patroon

Beheersing

• -contains, -icontains, -ccontains - verzameling bevat een waarde
• -notcontains, -inotcontains, -cnotcontains - verzameling bevat geen waarde
• -in, -iin, -cin - waarde bevindt zich in een verzameling
• -notin, -inotin, -cnotin - de waarde bevindt zich niet in een verzameling

type

• -is - beide objecten zijn hetzelfde type
• -isnot: de objecten zijn niet hetzelfde type

Algemene functies

Tekenreeksvergelijkingen zijn hoofdletterongevoelig, tenzij u de expliciete hoofdlettergevoelige operator gebruikt. Als u een vergelijkingsoperator hoofdlettergevoelig wilt maken, voegt u een c toe na de -. -ceq is bijvoorbeeld de hoofdlettergevoelige versie van -eq. Als u de hoofdletterongevoeligheid expliciet wilt maken, voegt u een i toe na -. -ieq is bijvoorbeeld de expliciet niet hoofdlettergevoelige versie van -eq.

Tekenreeksvergelijkingen maken gebruik van InvariantCulture voor zowel hoofdlettergevoelige als hoofdletterongevoelige vergelijkingen. De vergelijkingen zijn tussen Unicode-codepunten en gebruiken geen cultuurspecifieke sorteringsvolgorde. De resultaten zijn hetzelfde, ongeacht de huidige cultuur.

Wanneer de linkerwaarde in de vergelijkingsexpressie een scalaire waarde is, retourneert de operator een booleaanse waarde. Wanneer de linkerwaarde in de expressie een verzameling is, retourneert de operator de elementen van de verzameling die overeenkomen met de rechterwaarde van de expressie. Waarden aan de rechterkant worden altijd behandeld als singletonexemplaren, zelfs wanneer het verzamelingen zijn. De vergelijkingsoperatoren kunnen verzamelingen niet effectief vergelijken met verzamelingen.

Als de verzameling geen overeenkomsten bevat, retourneren vergelijkingsoperatoren een lege matrix. Bijvoorbeeld:

$a = (1, 2) -eq 3
$a.GetType().Name
$a.Count

Object[]
0

Er zijn enkele uitzonderingen:

• De insluitings- en typeoperators retourneren altijd een Booleaanse waarde
• De operator -replace retourneert het vervangingsresultaat
• De operators -match en -notmatch vullen ook de automatische $Matches variabele, tenzij de linkerkant van de expressie een verzameling is.

Gelijkheidsoperators

-eq en -ne

Wanneer de linkerkant een scalair is, retourneert -eqTrue als de rechterkant gelijkwaardig is, anders retourneert -eqFalse. -ne doet het tegenovergestelde; het retourneert Onwaar wanneer beide zijden gelijkwaardig zijn; anders retourneert -neTrue.

Voorbeeld:

2 -eq 2                 # Output: True
2 -eq 3                 # Output: False
'abc' -eq 'abc'         # Output: True
'abc' -eq 'abc', 'def'  # Output: False
'abc' -ne 'def'         # Output: True
'abc' -ne 'abc'         # Output: False
'abc' -ne 'abc', 'def'  # Output: True

Wanneer de linkerkant een verzameling is, retourneert -eq deze leden die overeenkomen met de rechterkant, terwijl -ne ze eruit filtert.

Voorbeeld:

1,2,3 -eq 2             # Output: 2
'abc', 'def' -eq 'abc'  # Output: abc
'abc', 'def' -ne 'abc'  # Output: def

Deze operators verwerken alle elementen van de verzameling. Voorbeeld:

'zzz', 'def', 'zzz' -eq 'zzz'

zzz
zzz

De gelijkheidsoperator kan objecten van verschillende typen vergelijken. Het is belangrijk om te begrijpen dat de waarde aan de rechterkant van de vergelijking kan worden geconverteerd naar het type linkse waarde voor vergelijking.

De tekenreeks '1.0' wordt bijvoorbeeld geconverteerd naar een geheel getal dat moet worden vergeleken met de waarde 1. In dit voorbeeld wordt Truegeretourneerd.

PS> 1 -eq '1.0'
True

In dit voorbeeld wordt de waarde 1 geconverteerd naar een tekenreeks die moet worden vergeleken met tekenreeks '1.0'. In dit voorbeeld wordt Falsegeretourneerd.

PS> '1.0' -eq 1
False

De gelijkheidsoperatoren accepteren twee objecten, niet alleen een scalaire of verzameling. Maar het vergelijkingsresultaat is niet gegarandeerd zinvol voor de eindgebruiker. In het volgende voorbeeld ziet u het probleem.

class MyFileInfoSet {
    [string]$File
    [int64]$Size
}
$a = [MyFileInfoSet]@{File = 'C:\Windows\explorer.exe'; Size = 4651032}
$b = [MyFileInfoSet]@{File = 'C:\Windows\explorer.exe'; Size = 4651032}
$a -eq $b

False

In dit voorbeeld hebben we twee objecten met identieke eigenschappen gemaakt. Toch is het resultaat van de gelijkheidstest Onwaar omdat ze verschillende objecten zijn. Als u vergelijkbare klassen wilt maken, moet u System.IEquatable<T-> in uw klas implementeren. In het volgende voorbeeld ziet u de gedeeltelijke implementatie van een MyFileInfoSet klasse die System.IEquatable<T-> implementeert en twee eigenschappen heeft, File en Size. De methode Equals() retourneert True als de eigenschappen Bestand en Grootte van twee MyFileInfoSet objecten hetzelfde zijn.

class MyFileInfoSet : System.IEquatable[Object] {
    [string]$File
    [int64]$Size

    [bool] Equals([Object] $obj) {
        return ($this.File -eq $obj.File) -and ($this.Size -eq $obj.Size)
    }
}
$a = [MyFileInfoSet]@{File = 'C:\Windows\explorer.exe'; Size = 4651032}
$b = [MyFileInfoSet]@{File = 'C:\Windows\explorer.exe'; Size = 4651032}
$a -eq $b

True

Een prominent voorbeeld van het vergelijken van willekeurige objecten is om erachter te komen of ze null zijn. Maar als u wilt bepalen of een variabele $nullis, moet u $null aan de linkerkant van de gelijkheidsoperator plaatsen. Als u het aan de rechterkant plaatst, werkt het niet zoals u verwacht.

Bijvoorbeeld, laat $a een array zijn die nul-elementen bevat.

$a = 1, 2, $null, 4, $null, 6

De volgende test controleert of $a niet nul is.

$null -ne $a

True

Het volgende filtert echter alle nul-elementen uit $a.

$a -ne $null # Output: 1, 2, 4, 6

1
2
4
6

-gt, -ge, -lt en -le

-gt, -ge, -lten -le zich op dezelfde manier gedragen. Wanneer beide zijden scalair zijn, resulteren ze in Waar of Onwaar, afhankelijk van hoe ze zich vergelijken:

Bediener	Geeft waar terug wanneer...
-gt	De linkerkant is groter
-ge	De linkerzijde is groter of gelijk aan
-lt	De linkerkant is kleiner
-le	De linkerkant is kleiner of gelijk aan

In de volgende voorbeelden retourneren alle uitspraken True.

8 -gt 6  # Output: True
8 -ge 8  # Output: True
6 -lt 8  # Output: True
8 -le 8  # Output: True

Notitie

In de meeste programmeertalen is de operator groter dan >. In PowerShell wordt dit teken gebruikt voor omleiding. Zie about_Redirectionvoor meer informatie.

Wanneer de linkerkant een verzameling is, vergelijken deze operators elk lid van de verzameling met de rechterkant. Afhankelijk van hun logica behouden of verwijderen ze het lid.

Voorbeeld:

$a=5, 6, 7, 8, 9

Write-Output 'Test collection:'
$a

Write-Output "`nMembers greater than 7"
$a -gt 7

Write-Output "`nMembers greater than or equal to 7"
$a -ge 7

Write-Output "`nMembers smaller than 7"
$a -lt 7

Write-Output "`nMembers smaller than or equal to 7"
$a -le 7

Test collection:
5
6
7
8
9

Members greater than 7
8
9

Members greater than or equal to 7
7
8
9

Members smaller than 7
5
6

Members smaller than or equal to 7
5
6
7

Deze operators werken met elke klasse die System.IComparableimplementeert.

Voorbeelden:

# Date comparison
[datetime]'2001-11-12' -lt [datetime]'2020-08-01' # True

# Sorting order comparison
'a' -lt 'z'           # True; 'a' comes before 'z'
'macOS' -ilt 'MacOS'  # False
'MacOS' -ilt 'macOS'  # False
'macOS' -clt 'MacOS'  # True; 'm' comes before 'M'

In het volgende voorbeeld ziet u dat er geen symbool is op een Amerikaans QWERTY-toetsenbord dat na 'a' wordt gesorteerd. Het voedt een set met al deze symbolen aan de -gt operator om ze te vergelijken met 'a'. De uitvoer is een lege matrix.

$a=' ','`','~','!','@','#','$','%','^','&','*','(',')','_','+','-','=',
   '{','}','[',']',':',';','"','''','\','|','/','?','.','>',',','<'
$a -gt 'a'
# Output: Nothing

Als de twee zijden van de operators niet voldoende vergelijkbaar zijn, veroorzaken deze operators een niet-afsluitende fout.

Overeenkomende operators

De overeenkomende operatoren (-like, -notlike, -matchen -notmatch) zoeken elementen die overeenkomen met of niet overeenkomen met een opgegeven patroon. Het patroon voor -like en -notlike is een jokertekenexpressie (met *, ?en [ ]), en -match-notmatch accepteert een reguliere expressie (regex).

De syntaxis is:

<string[]> -like    <wildcard-expression>
<string[]> -notlike <wildcard-expression>
<string[]> -match    <regular-expression>
<string[]> -notmatch <regular-expression>

Wanneer de invoer van deze operators een scalaire waarde is, retourneren ze een Booleaanse waarde.

Wanneer de invoer een verzameling waarden is, wordt elk item in de verzameling geconverteerd naar een tekenreeks ter vergelijking. De operators -match en -notmatch retourneren respectievelijk overeenkomende en niet-overeenkomende leden. De operators -like en -notlike retourneren echter de leden als tekenreeksen. De tekenreeks die wordt geretourneerd voor een lid van de verzameling, zoals aangegeven door -like en -notlike, is de tekenreeks die de operator voor de vergelijking gebruikt en wordt verkregen door het lid om te zetten naar een tekenreeks.

-like en -notlike

-like en -notlike gedragen zich op een vergelijkbare manier als -eq en -ne, maar de rechterkant kan een tekenreeks zijn die jokertekens bevat.

Voorbeeld:

'PowerShell' -like    '*shell'           # Output: True
'PowerShell' -notlike '*shell'           # Output: False
'PowerShell' -like    'Power?hell'       # Output: True
'PowerShell' -notlike 'Power?hell'       # Output: False
'PowerShell' -like    'Power[p-w]hell'   # Output: True
'PowerShell' -notlike 'Power[p-w]hell'   # Output: False

'PowerShell', 'Server' -like '*shell'    # Output: PowerShell
'PowerShell', 'Server' -notlike '*shell' # Output: Server

Voor de beste resultaten moet de rechterzijde van de -like en -notlike operatoren een letterlijke tekenreeks zijn die de expressie met jokertekens bevat. PowerShell geeft de jokertekenexpressie door aan de parser voor jokertekenexpressie. Als u een van de jokertekens (*, of?) wilt vergelijken, [ ]moet u deze escapen met een backtick (`teken). Als u bijvoorbeeld een letterlijke waarde ?wilt vergelijken, gebruikt `? u deze in de jokertekenexpressie. Als u een uitbreidbare tekenreeksexpressie gebruikt, wordt de tekenreeks uitgebreid voordat deze wordt doorgegeven aan de parser met jokertekens. Dit resulteert in niet-gescaped tekens die als jokertekens worden verzonden.

# Escaped literals in an expandable string
PS> "f`?`?"
f??
# Escaped literals in a literal string
PS> 'f`?`?'
f`?`?
# Comparison containing 2 wildcards
PS> 'f??' -like 'f??'
True
PS> 'for' -like 'f??'
True
# Comparison containing literal '?' characters
PS> 'f??' -like 'f`?`?'
True
PS> 'for' -like 'f`?`?'
False

-match en -notmatch

-match en -notmatch maken gebruik van reguliere expressies om te zoeken naar een patroon in de waarden aan de linkerzijde. Reguliere expressies kunnen overeenkomen met complexe patronen, zoals e-mailadressen, UNC-paden of opgemaakte telefoonnummers. De tekenreeks aan de rechterkant moet voldoen aan de regels van de reguliere expressies .

Scalaire voorbeelden:

# Partial match test, showing how differently -match and -like behave
'PowerShell' -match 'shell'        # Output: True
'PowerShell' -like  'shell'        # Output: False

# Regex syntax test
'PowerShell' -match    '^Power\w+' # Output: True
'bag'        -notmatch 'b[iou]g'   # Output: True

Als de invoer een verzameling is, retourneren de operators de overeenkomende leden van die verzameling.

Voorbeelden van verzamelingen:

'PowerShell', 'Super PowerShell', 'Power's hell' -match '^Power\w+'
# Output: PowerShell

'Rhell', 'Chell', 'Mel', 'Smell', 'Shell' -match 'hell'
# Output: Rhell, Chell, Shell

'Bag', 'Beg', 'Big', 'Bog', 'Bug'  -match 'b[iou]g'
#Output: Big, Bog, Bug

'Bag', 'Beg', 'Big', 'Bog', 'Bug'  -notmatch 'b[iou]g'
#Output: Bag, Beg

-match en -notmatch ondersteunen regex capture-groepen. Elke keer dat ze draaien met scalaire invoer en het resultaat -match is waar, of het resultaat -notmatch is onwaar, overschrijven ze de $Matches automatische variabele. $Matches is een Hashtable- die altijd een sleutel met de naam 0 heeft, waarmee de hele overeenkomst wordt opgeslagen. Als de reguliere expressie capture-groepen bevat, bevat de $Matches extra sleutels voor elke groep.

Het is belangrijk te weten dat de $Matches hashtabel alleen het eerste exemplaar van een overeenkomend patroon bevat.

Voorbeeld:

$string = 'The last logged on user was CONTOSO\jsmith'
$string -match 'was (?<domain>.+)\\(?<user>.+)'

$Matches

Write-Output "`nDomain name:"
$Matches.domain

Write-Output "`nUser name:"
$Matches.user

True

Name                           Value
----                           -----
domain                         CONTOSO
user                           jsmith
0                              was CONTOSO\jsmith

Domain name:
CONTOSO

User name:
jsmith

Wanneer het resultaat -matchOnwaaris, of het resultaat -notmatchWaaris, of wanneer de invoer een verzameling is, wordt de automatische variabele $Matches niet overschreven. Daarom bevat deze de eerder ingestelde waarde of $null als de variabele niet is ingesteld. Wanneer u verwijst naar $Matches nadat u een van deze operators hebt aangeroepen, kunt u controleren of de variabele is ingesteld door de huidige operatoraanroep met behulp van een voorwaarde-instructie.

Voorbeeld:

if ('<version>1.0.0</version>' -match '<version>(.*?)</version>') {
    $Matches
}

Zie about_Regular_Expressions en about_Automatic_Variablesvoor meer informatie.

Vervangingsoperator

Vervanging met reguliere expressies

Net als -matchgebruikt de operator -replace reguliere expressies om het opgegeven patroon te vinden. Maar in tegenstelling tot -matchvervangt het de overeenkomsten door een andere gespecificeerde waarde.

Syntaxis:

<input> -replace <regular-expression>, <substitute>

De operator vervangt alle of een deel van een waarde door de opgegeven waarde met behulp van reguliere expressies. U kunt de operator gebruiken voor veel beheertaken, zoals het wijzigen van de naam van bestanden. Met de volgende opdracht worden bijvoorbeeld de bestandsnaamextensies van alle .txt bestanden gewijzigd in .log:

Get-ChildItem *.txt | Rename-Item -NewName { $_.Name -replace '\.txt$','.log' }

De operator -replace is standaard niet hoofdlettergevoelig. Gebruik -creplaceom het hoofdlettergevoelig te maken. Gebruik -ireplaceom deze expliciet niet hoofdlettergevoelig te maken.

Voorbeelden:

'book' -ireplace 'B', 'C' # Case insensitive
'book' -creplace 'B', 'C' # Case-sensitive; hence, nothing to replace

Cook
book

Vanaf PowerShell 7.2 wordt, wanneer de linkerkant van een -replace-operatie geen tekenreeks is, die operand omgezet naar een tekenreeks. PowerShell voert een cultuuronafhankelijke tekenreeksconversie uit.

Als uw cultuur bijvoorbeeld is ingesteld op Frans (fr), wordt de cultuurgevoelige tekenreeksconversie van waarde 1.21,2.

Vóór PowerShell 7.2:

PS> [cultureinfo]::CurrentCulture = 'fr'
PS> 1.2 -replace ','
12

In PowerShell 7.2 en hoger:

PS> [cultureinfo]::CurrentCulture = 'fr'
PS> 1.2 -replace ','
1.2

Vervangingen van reguliere expressies

Het is ook mogelijk om reguliere expressies te gebruiken om tekst dynamisch te vervangen met behulp van het vastleggen van groepen en vervangingen. Verwijs naar capture-groepen in de tekenreeks <substitute> met behulp van het dollarteken ($) vóór de groeps-ID.

In het volgende voorbeeld accepteert de operator -replace een gebruikersnaam in de vorm van DomainName\Username en converteert deze naar de Username@DomainName-indeling:

$SearchExp = '^(?<DomainName>[\w-.]+)\\(?<Username>[\w-.]+)$'
$ReplaceExp = '${Username}@${DomainName}'

'Contoso.local\John.Doe' -replace $SearchExp, $ReplaceExp

John.Doe@Contoso.local

Waarschuwing

Het $ teken heeft syntactische rollen in zowel PowerShell als reguliere expressies:

• In PowerShell worden tussen dubbele aanhalingstekens variabelen aangewezen en fungeert deze als een operator voor subexpressie.
• In Regex-zoekreeksen wordt het einde van de regel aangeduid.
• In Regex-vervangingstekenreeksen worden vastgelegde groepen aangeduid. Zorg ervoor dat u reguliere expressies tussen enkele aanhalingstekens plaatst of een backtick-teken (`) ervoor zet.

Bijvoorbeeld:

$1 = 'Goodbye'

'Hello World' -replace '(\w+) \w+', "$1 Universe"
# Output: Goodbye Universe

'Hello World' -replace '(\w+) \w+', '$1 Universe'
# Output: Hello Universe

$$ in Regex geeft een letterlijke $aan. Gebruik het $$ in de vervangingstekenreeks om een letterlijke $ in de resulterende vervanging op te nemen. Bijvoorbeeld:

'5.72' -replace '(.+)', '$ $1' # Output: $ 5.72
'5.72' -replace '(.+)', '$$$1' # Output: $5.72
'5.72' -replace '(.+)', '$$1'  # Output: $1

Zie about_Regular_Expressions en Vervangingen in reguliere expressiesvoor meer informatie.

Vervangen in een verzameling

Wanneer de <input> op de operator -replace een verzameling is, past PowerShell de vervanging toe op elke waarde in de verzameling. Bijvoorbeeld:

'B1','B2','B3','B4','B5' -replace 'B', 'a'
a1
a2
a3
a4
a5

Vervanging met een scriptblok

In PowerShell 6 en hoger accepteert de -replace operator ook een scriptblok waarmee de vervanging wordt uitgevoerd. De scriptblock wordt één keer uitgevoerd voor elke overeenkomst.

Syntaxis:

<String> -replace <regular-expression>, {<Script-block>}

Gebruik in het scriptblok de $_ automatische variabele om toegang te krijgen tot de invoertekst die wordt vervangen en andere nuttige informatie. Het klassetype van deze variabele is System.Text.RegularExpressions.Match.

In het volgende voorbeeld wordt elke reeks van drie cijfers vervangen door de tekenequivalenten. Het scriptblok wordt uitgevoerd voor elke set van drie cijfers die moeten worden vervangen.

'072101108108111' -replace '\d{3}', {return [char][int]$_.Value}

Hello

Insluitingsoperators

De insluitingsoperatoren (-contains, -notcontains, -inen -notin) zijn vergelijkbaar met de gelijkheidsoperatoren, behalve dat ze altijd een booleaanse waarde retourneren, zelfs wanneer de invoer een verzameling is. Deze operators stoppen met vergelijken zodra ze de eerste overeenkomst detecteren, terwijl de gelijkheidsoperators alle invoerelementen evalueren. In een zeer grote verzameling zullen deze operators sneller resultaten geven dan de gelijkheidsoperators.

-bevat en -notcontains

Syntaxis:

<Collection> -contains <scalar-object>
<Collection> -notcontains <scalar-object>

Deze operators geven aan of een set een bepaald element bevat. -contains retourneert True wanneer de rechterkant (scalar-object) overeenkomt met een van de elementen in de set. -notcontains retourneert in plaats daarvan False.

Voorbeelden:

'abc', 'def' -contains 'def'                  # Output: True
'abc', 'def' -notcontains 'def'               # Output: False
'Windows', 'PowerShell' -contains 'Shell'     # Output: False
'Windows', 'PowerShell' -notcontains 'Shell'  # Output: True
'abc', 'def', 'ghi' -contains 'abc', 'def'    # Output: False
'abc', 'def', 'ghi' -notcontains 'abc', 'def' # Output: True

Complexere voorbeelden:

$DomainServers = 'ContosoDC1', 'ContosoDC2', 'ContosoFileServer',
                 'ContosoDNS', 'ContosoDHCP', 'ContosoWSUS'
$thisComputer  = 'ContosoDC2'

$DomainServers -contains $thisComputer
# Output: True

Wanneer de operand aan de rechterkant een verzameling is, converteren deze operators de waarde naar de tekenreeksweergave voordat deze wordt vergeleken met de verzameling aan de linkerkant.

$a = 'abc', 'def'
'abc', 'def', 'ghi' -contains $a # Output: False

# The following statements are equivalent
$a, 'ghi' -contains $a           # Output: True
'$a', 'ghi' -contains $a         # Output: True
'abc def', 'ghi' -contains $a    # Output: True

-in en -notin

Syntaxis:

<scalar-object> -in <Collection>
<scalar-object> -notin <Collection>

De operators -in en -notin zijn in PowerShell 3 geïntroduceerd als syntactisch omgekeerd van de operatoren -contains en -notcontains. -in retourneert True wanneer de linkerzijde <scalar-object> overeenkomt met een van de elementen in de verzameling. -notin retourneert False in plaats daarvan.

De volgende voorbeelden doen hetzelfde wat de voorbeelden voor -contains en -notcontains doen, maar ze worden geschreven met -in en -notin.

'def' -in 'abc', 'def'                  # Output: True
'def' -notin 'abc', 'def'               # Output: False
'Shell' -in 'Windows', 'PowerShell'     # Output: False
'Shell' -notin 'Windows', 'PowerShell'  # Output: True
'abc', 'def' -in 'abc', 'def', 'ghi'    # Output: False
'abc', 'def' -notin 'abc', 'def', 'ghi' # Output: True

Complexere voorbeelden:

$DomainServers = 'ContosoDC1', 'ContosoDC2', 'ContosoFileServer',
                 'ContosoDNS', 'ContosoDHCP', 'ContosoWSUS'
$thisComputer  = 'ContosoDC2'

$thisComputer -in $DomainServers
# Output: True

Wanneer de operand aan de linkerkant een verzameling is, converteren deze operators de waarde naar de tekenreeksweergave voordat deze wordt vergeleken met de verzameling aan de rechterkant.

$a = 'abc', 'def'
$a -in 'abc', 'def', 'ghi' # Output: False

# The following statements are equivalent
$a -in $a, 'ghi'           # Output: True
$a -in '$a', 'ghi'         # Output: True
$a -in 'abc def', 'ghi'    # Output: True

Typevergelijking

De operatoren voor typevergelijking (-is en -isnot) worden gebruikt om te bepalen of een object een specifiek type is.

Syntaxis:

<object> -is <type-reference>
<object> -isnot <type-reference>

Voorbeeld:

$a = 1
$b = '1'
$a -is [int]           # Output: True
$a -is $b.GetType()    # Output: False
$b -isnot [int]        # Output: True
$a -isnot $b.GetType() # Output: True

Zie ook

• about_Booleans
• over_Operatoren
• over_reguliere_expressies
• over_Jokertekens
• Vergelijken-object
• ForEach-Object
• Waar-Object