about_Comparison_Operators
Korte beschrijving
De vergelijkingsoperatoren in PowerShell kunnen twee waarden vergelijken of elementen van een verzameling filteren met een invoerwaarde.
Lange beschrijving
Met vergelijkingsoperatoren kunt u waarden vergelijken of waarden vinden die overeenkomen met opgegeven patronen. PowerShell bevat de volgende vergelijkingsoperators:
Gelijkheid
-eq
,-ieq
,-ceq
- is gelijk aan-ne
,-ine
--cne
is niet gelijk aan-gt
-cgt
,-igt
- groter dan-ge
-cge
,-ige
- groter dan of gelijk aan-lt
,-ilt
--clt
kleiner dan-le
-cle
,-ile
- 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 van hetzelfde type zijn-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
.
Tekenreeksvergelijkingen gebruiken de InvariantCulture voor zowel hoofdlettergevoelige als niet-hoofdlettergevoelige vergelijkingen. De vergelijkingen zijn tussen Unicode-codepunten en maken geen gebruik van cultuurspecifieke sorteringsvolgorde. De resultaten zijn hetzelfde, ongeacht de huidige cultuur.
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
operators 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 gelijkwaardig is. -eq
Anders wordt Onwaar geretourneerd. -ne
doet het tegenovergestelde; het retourneert False wanneer beide zijden gelijkwaardig zijn; -ne
anders, retourneert Waar.
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 gefilterd.
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 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 True
geretourneerd.
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 False
geretourneerd.
PS> '1.0' -eq 1
False
De gelijkheidsoperatoren accepteren twee objecten, niet alleen een scalaire 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 False omdat het verschillende objecten zijn. Als u vergelijkbare klassen wilt maken, moet u System.IEquatable<T> implementeren in uw klasse. 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 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 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 zijn $a
niet null.
$null -ne $a
True
Het volgende verwijdert echter alle null-elementen van $a
:
$a -ne $null # Output: 1, 2, 4, 6
1
2
4
6
-gt, -ge, -lt, en -le
-gt
, -ge
, -lt
en -le
gedragen zich op dezelfde manier. Wanneer beide zijden scalair zijn, retourneren ze Waar of Onwaar , afhankelijk van hoe de twee zijden zich verhouden:
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 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.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 voert 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 operators niet redelijk vergelijkbaar zijn, veroorzaken deze operators een niet-afsluitfout.
Overeenkomende operators
De overeenkomende operators (-like
, -notlike
, -match
en -notmatch
) zoeken elementen die al dan 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, wordt elk item in de verzameling geconverteerd naar een tekenreeks voor vergelijking. De -match
operators en -notmatch
retourneren respectievelijk overeenkomende en niet-overeenkomende leden. -like
De operators en -notlike
retourneren de leden echter als tekenreeksen. De tekenreeks die wordt geretourneerd voor een lid van de verzameling door -like
en -notlike
is de tekenreeks die de operator voor de vergelijking heeft gebruikt en wordt verkregen door het lid naar een tekenreeks te casten.
-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 een 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. Telkens wanneer 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 volledige 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 -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
naar een van deze operators nadat u een van deze operators hebt aangeroepen, kunt u controleren of de variabele is ingesteld door de huidige operatoraanroep met behulp van een voorwaardeinstructie.
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 -creplace
om het hoofdlettergevoelig te maken. Als u de app expliciet hoofdlettergevoelig wilt maken, gebruikt -ireplace
u .
Voorbeelden:
"book" -ireplace "B", "C" # Case insensitive
"book" -creplace "B", "C" # Case-sensitive; hence, nothing to replace
Cook
book
Vanaf PowerShell 7.2 wordt de operand geconverteerd naar een tekenreeks wanneer de linkeroperand in een -replace
operatorinstructie geen tekenreeks is.
PowerShell voert een cultuurgevoelige tekenreeksconversie uit.
Als uw cultuur bijvoorbeeld is ingesteld op Frans (fr), is 1,2
de cultuurgevoelige tekenreeksconversie van waarde 1.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 voor 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, tussen dubbele aanhalingstekens, wijst het variabelen aan en fungeert als een operator voor subexpressie.
- In Regex-zoekreeksen geeft dit het einde van de regel aan.
- In Regex-vervangingsreeksen geeft dit vastgelegde groepen aan. Zorg ervoor dat u de reguliere expressies tussen enkele aanhalingstekens plaatst of een backtick (
`
) voor de expressies plaatst.
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>
op 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 eenmaal 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
, -in
en -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 invoerleden evalueren. In een zeer grote verzameling retourneren deze operatoren sneller dan de gelijkheidsoperatoren.
-contains en -notcontains
Syntaxis:
<Collection> -contains <scalar-object>
<Collection> -notcontains <scalar-object>
Deze operators geven aan of een set een bepaald element bevat. -contains
retourneert Waar wanneer de rechterkant (scalair-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 ze deze vergelijken 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 -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 <scalar-object>
overeenkomt met een van de elementen in de verzameling. -notin
retourneert in plaats daarvan False.
De volgende voorbeelden doen hetzelfde als de voorbeelden voor -contains
en -notcontains
doen, 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
Wanneer de operand aan de linkerkant een verzameling is, converteren deze operatoren 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 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