about_Comparison_Operators

Artikel
05/09/2024

Korte beschrijving

De vergelijkingsoperators 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 vinden die overeenkomen met opgegeven patronen. PowerShell bevat de volgende vergelijkingsoperatoren:

Gelijkheid

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

Matching

-like, -ilike, - -clike tekenreeks komt overeen met jokertekenpatroon
-notlike, -inotlike, -cnotlike - tekenreeks komt niet overeen met jokertekenpatroon
-match, -imatch, -cmatch - tekenreeks komt overeen met regex-patroon
-notmatch, -inotmatch, -cnotmatch - tekenreeks komt niet overeen met regex-patroon

Vervanging

-replace, -ireplace, -creplace - vervangt tekenreeksen die overeenkomen met een regex-patroon

Containment

-contains, -icontains, -ccontains - verzameling bevat een waarde
-notcontains, -inotcontains, -cnotcontains - verzameling bevat geen waarde
-in - waarde bevindt zich in een verzameling
-notin - waarde bevindt zich niet in een verzameling

Type

-is - beide objecten zijn van hetzelfde type
-isnot - de objecten zijn niet van hetzelfde type

Algemene functies

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

Wanneer de invoer van een operator een scalaire waarde is, retourneert de operator een Booleaanse waarde. Wanneer de invoer een verzameling is, retourneert de operator de elementen van de verzameling die overeenkomen met de rechterwaarde van de expressie. 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 typeoperatoren retourneren altijd een Booleaanse waarde
De -replace operator retourneert het vervangingsresultaat
De -match operatoren en -notmatch vullen ook de $Matches automatische variabele in, tenzij de linkerkant van de expressie een verzameling is.

Gelijkheidsoperatoren

-eq en -ne

Wanneer de linkerkant scalair is, -eq retourneert True als de rechterkant een exacte overeenkomst is, anders -eq wordt Onwaar geretourneerd. -ne doet het tegenovergestelde; het retourneert False wanneer beide zijden overeenkomen; -ne anders retourneert True.

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, -eq worden de leden geretourneerd die overeenkomen met de rechterkant, terwijl -ne ze worden uitgefilterd.

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 weten dat de waarde aan de rechterkant van de vergelijking kan worden geconverteerd naar het type van de waarde aan de linkerkant 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. Het resultaat van de gelijkheidstest is echter Onwaar omdat het verschillende objecten zijn. Als u vergelijkbare klassen wilt maken, moet u System.IEquatable<T> in uw klasse implementeren. In het volgende voorbeeld ziet u de gedeeltelijke implementatie van een MyFileInfoSet-klasse die System.IEquatable<T> implementeert en twee eigenschappen heeft: Bestand en Grootte. De Equals() methode retourneert True als

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 is $null, moet u aan de linkerkant van de gelijkheidsoperator plaatsen $null . Als je het aan de rechterkant plaatst, doe je niet wat je verwacht.

Laat $a bijvoorbeeld een matrix zijn die null-elementen bevat:

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

De volgende tests die $a niet null zijn.

$null -ne $a

True

De volgende filers echter alle null-elementen van $a:

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

-gt, -ge, -lt, en -le

-gt, -ge, -lten -le gedragen zich op dezelfde manier. Wanneer beide zijden scalair zijn, retourneren ze Waar of Onwaar , afhankelijk van de vergelijking tussen de twee zijden:

Operator	Retourneert Waar wanneer...
`-gt`	De linkerkant is groter
`-ge`	De linkerkant is groter of gelijk aan
`-lt`	De linkerkant is kleiner
`-le`	De linkerkant is kleiner of gelijk aan

In de volgende voorbeelden retourneren alle -instructies Waar.

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_Redirection voor meer informatie.

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

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.IComparable implementeert.

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 wordt gesorteerd op 'a'. Het voedt een set met al deze symbolen naar de -gt operator om deze te vergelijken met 'a'. De uitvoer is een lege matrix.

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

Als de twee zijden van de operatoren niet redelijk vergelijkbaar zijn, veroorzaken deze operatoren een niet-afsluitfout.

Overeenkomende operators

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

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, retourneren de operators overeenkomende leden. Als er geen overeenkomsten in een verzameling zijn, retourneren de operators een lege matrix.

-like en -notlike

-like en -notlike gedragen zich op dezelfde manier -eq als 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

-match en -notmatch

-match en -notmatch gebruik reguliere expressies om te zoeken naar patroon in de waarden aan de linkerkant. 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 voor 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 worden uitgevoerd op scalaire invoer en het -match resultaat Waar is, of het -notmatch resultaat Onwaar is, overschrijven ze de $Matches automatische variabele. $Matches is een hashtabel die altijd een sleutel met de naam '0' heeft, waarin de hele overeenkomst wordt opgeslagen. Als de reguliere expressie vastleggroepen 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 -match resultaat Onwaar is of het -notmatch resultaat Waar is, of wanneer de invoer een verzameling is, wordt de $Matches automatische variabele niet overschreven. Als gevolg hiervan bevat deze de eerder ingestelde waarde, of $null als de variabele niet is ingesteld. Wanneer u verwijst $Matches na het aanroepen van een van deze operatoren, 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_Variables voor meer informatie.

Vervangende operator

Vervangen door reguliere expressies

Net als -match, gebruikt de -replace operator reguliere expressies om het opgegeven patroon te vinden. Maar in tegenstelling tot -match, worden de overeenkomsten vervangen door een andere opgegeven waarde.

Syntaxis:

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

De operator vervangt een waarde geheel of gedeeltelijk 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 is standaard -replace niet hoofdlettergevoelig. Gebruik -creplaceom het hoofdlettergevoelig te maken. Als u de app expliciet hoofdlettergevoelig wilt maken, gebruikt -ireplaceu .

Voorbeelden:

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

Cook
book

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. Er kan in de <substitute> tekenreeks worden verwezen naar capture-groepen met behulp van het dollarteken ($) vóór de groeps-id.

In het volgende voorbeeld accepteert de -replace operator 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 opgegeven en fungeert het als een operator voor subexpressie.
In Regex-zoektekenreeksen wordt het einde van de regel aangegeven.
In regex-vervangingsreeksen geeft het vastgelegde groepen aan. Zorg ervoor dat u de reguliere expressies tussen enkele aanhalingstekens plaatst of er een backtick (`) voor invoegt.

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 $. Dit $$ in de vervangingstekenreeks om een letterlijke $ waarde op te nemen in de resulterende vervanging. 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 expressies voor meer informatie.

Vervangen in een verzameling

Wanneer de <input> naar de -replace operator 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

Vervangen door een scriptblok

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

Syntaxis:

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

Gebruik in het scriptblok de $_ automatische variabele voor toegang 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 moet worden vervangen.

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

Hello

Insluitingsoperatoren

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

Syntaxis:

<Collection> -contains <Test-object>
<Collection> -notcontains <Test-object>
<Test-object> -in <Collection>
<Test-object> -notin <Collection>

-contains en -notcontains

Deze operators geven aan of een set een bepaald element bevat. -contains retourneert Waar wanneer de rechterkant (testobject) overeenkomt met een van de elementen in de set. -notcontains retourneert in plaats daarvan False. Wanneer het testobject een verzameling is, gebruiken deze operators verwijzingsgelijkheid, d.w.z. ze controleren of een van de elementen van de set hetzelfde exemplaar van het testobject is.

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

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

-in en -notin

De -in operators en -notin zijn in PowerShell 3 geïntroduceerd als het syntactische omgekeerde van de operators van -contains en -notcontains . -in retourneert Waar wanneer de linkerkant <test-object> overeenkomt met een van de elementen in de set. -notin retourneert in plaats daarvan False . Wanneer het testobject een set is, gebruiken deze operators verwijzingsgelijkheid om te controleren of een van de elementen van de set hetzelfde exemplaar van het testobject is.

De volgende voorbeelden doen hetzelfde als de voorbeelden voor -contains en -notcontains , maar ze zijn 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

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

Typevergelijking

De typevergelijkingsoperatoren (-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

Delen via

about_Comparison_Operators

Korte beschrijving

Lange beschrijving

Algemene functies

Gelijkheidsoperatoren

-eq en -ne

-gt, -ge, -lt, en -le

Overeenkomende operators

-like en -notlike

-match en -notmatch

Vervangende operator

Vervangen door reguliere expressies

Vervangingen van reguliere expressies

Vervangen in een verzameling

Vervangen door een scriptblok

Insluitingsoperatoren

-contains en -notcontains

-in en -notin

Typevergelijking

Zie ook

Aanvullende resources