about_Comparison_Operators
Kurze Beschreibung
Die Vergleichsoperatoren in PowerShell können entweder zwei Werte vergleichen oder Elemente einer Auflistung mit einem Eingabewert filtern.
Lange Beschreibung
Mit Vergleichsoperatoren können Sie Werte vergleichen oder Werte finden, die mit angegebenen Mustern übereinstimmen. PowerShell umfasst die folgenden Vergleichsoperatoren:
Gleichheit
-eq
,-ieq
,-ceq
- gleich-ne
,-ine
,-cne
- nicht gleich-gt
,-igt
,-igt
- größer als-ge
,-ige
,-cge
- größer als oder gleich-lt
,-ilt
,-clt
- kleiner als-le
,-ile
,-cle
- kleiner oder gleich
Passende
-like
,-ilike
,-clike
- Zeichenfolge stimmt mit Einem Wildcard-Muster überein-notlike
,-inotlike
,-cnotlike
- Zeichenfolge stimmt nicht mit dem Wildcardmuster überein-match
,-imatch
, --cmatch
Zeichenfolge entspricht regex-Muster-notmatch
,-inotmatch
,-cnotmatch
- Zeichenfolge stimmt nicht mit regex-Muster überein
Ersatz
-replace
,-ireplace
,-creplace
- ersetzt Zeichenfolgen, die einem Regex-Muster entsprechen
Containment
-contains
,-icontains
,-ccontains
- Auflistung enthält einen Wert-notcontains
,-inotcontains
,-cnotcontains
- Auflistung enthält keinen Wert-in
- Wert befindet sich in einer Auflistung-notin
- Wert befindet sich nicht in einer Auflistung
Typ
-is
- Beide Objekte sind derselbe Typ-isnot
- Die Objekte sind nicht derselbe Typ
Allgemeine Funktionen
Bei Zeichenfolgenvergleichen wird die Groß-/Kleinschreibung nicht beachtet, es sei denn, Sie verwenden den expliziten Operator, der die Groß-/Kleinschreibung beachtet. Um die Groß-/Kleinschreibung eines Vergleichsoperators zu berücksichtigen, fügen Sie nach dem -
hinzuc
. Bei der Version von z. -ceq
B. wird die Groß-/Kleinschreibung berücksichtigt -eq
.
Um die Groß-/Kleinschreibung explizit zu machen, fügen Sie nach -
hinzui
. Beispielsweise -ieq
ist die Explizite Nicht-Groß-/Kleinschreibung-Version von -eq
.
Wenn die Eingabe eines Operators ein skalarer Wert ist, gibt der Operator einen booleschen Wert zurück. Wenn es sich bei der Eingabe um eine Auflistung handelt, gibt der Operator die Elemente der Auflistung zurück, die dem rechten Wert des Ausdrucks entsprechen. Wenn keine Übereinstimmungen in der Auflistung vorhanden sind, geben Vergleichsoperatoren ein leeres Array zurück. Beispiel:
$a = (1, 2 -eq 3)
$a.GetType().Name
$a.Count
Object[]
0
Es gibt ein paar Ausnahmen:
- Die Containment- und Typoperatoren geben immer einen booleschen Wert zurück.
- Der
-replace
Operator gibt das Ersatzergebnis zurück. - Die
-match
Operatoren und-notmatch
füllen auch die$Matches
automatische Variable auf, es sei denn, die linke Seite des Ausdrucks ist eine Auflistung.
Gleichheitsoperatoren
-eq und -ne
Wenn die linke Seite skalar ist, gibt True zurück, -eq
wenn die rechte Seite eine exakte Übereinstimmung aufweist, -eq
andernfalls False. -ne
tut das Gegenteil; Es gibt False zurück, wenn beide Seiten übereinstimmen. Andernfalls -ne
wird True zurückgegeben.
Beispiel:
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
Wenn die linke Seite eine Auflistung ist, gibt die Elemente zurück, -eq
die der rechten Seite entsprechen, während -ne
sie herausgefiltert werden.
Beispiel:
1,2,3 -eq 2 # Output: 2
"abc", "def" -eq "abc" # Output: abc
"abc", "def" -ne "abc" # Output: def
Diese Operatoren verarbeiten alle Elemente der Auflistung. Beispiel:
"zzz", "def", "zzz" -eq "zzz"
zzz
zzz
Der Gleichheitsoperator kann Objekte unterschiedlicher Typen vergleichen. Es ist wichtig zu verstehen, dass der Wert auf der rechten Seite des Vergleichs in den Typ des linksseitigen Werts für den Vergleich konvertiert werden kann.
Beispielsweise wird die Zeichenfolge '1.0'
in eine ganze Zahl konvertiert, um mit dem Wert 1
verglichen zu werden. In diesem Beispiel wird zurückgegeben True
.
PS> 1 -eq '1.0'
True
In diesem Beispiel wird der Wert 1
in eine Zeichenfolge konvertiert, um mit Zeichenfolge '1.0'
verglichen zu werden. In diesem Beispiel wird zurückgegeben False
.
PS> '1.0' -eq 1
False
Die Gleichheitsoperatoren akzeptieren zwei beliebige Objekte, nicht nur einen Skalar oder eine Auflistung. Das Vergleichsergebnis ist jedoch nicht garantiert, dass es für den Endbenutzer aussagekräftig ist. Das folgende Beispiel veranschaulicht das Problem.
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 diesem Beispiel haben wir zwei Objekte mit identischen Eigenschaften erstellt. Das Gleichheitstestergebnis ist jedoch False , da es sich um unterschiedliche Objekte handelt. Um vergleichbare Klassen zu erstellen, müssen Sie System.IEquatable<T> in Ihrer Klasse implementieren. Im folgenden Beispiel wird die partielle Implementierung einer MyFileInfoSet-Klasse veranschaulicht, die System.IEquatable<T> implementiert und über zwei Eigenschaften verfügt: File und Size. Die Equals()
Methode gibt True zurück, wenn
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
Ein prominentes Beispiel für den Vergleich beliebiger Objekte ist die Ermittlung, ob sie NULL sind. Wenn Sie jedoch feststellen müssen, ob eine Variable ist $null
, müssen Sie auf der linken Seite des Gleichheitsoperators platzieren $null
. Es auf der rechten Seite zu platzieren, erfüllt nicht das, was Sie erwarten.
Lassen Sie uns $a
beispielsweise ein Array sein, das NULL-Elemente enthält:
$a = 1, 2, $null, 4, $null, 6
Die folgenden Tests, die $a
nicht NULL sind.
$null -ne $a
True
Im Folgenden werden jedoch alle NULL-Elemente aus filern:$a
$a -ne $null # Output: 1, 2, 4, 6
1
2
4
6
-gt, -ge, -lt und -le
-gt
, -ge
, -lt
und -le
verhalten sich sehr ähnlich. Wenn beide Seiten skalar sind, geben sie True oder False zurück, je nachdem, wie die beiden Seiten verglichen werden:
Betreiber | Gibt True zurück, wenn... |
---|---|
-gt |
Die linke Seite ist größer |
-ge |
Die linke Seite ist größer oder gleich |
-lt |
Die linke Seite ist kleiner |
-le |
Die linke Seite ist kleiner oder gleich |
In den folgenden Beispielen geben alle Anweisungen True zurück.
8 -gt 6 # Output: True
8 -ge 8 # Output: True
6 -lt 8 # Output: True
8 -le 8 # Output: True
Hinweis
In den meisten Programmiersprachen ist >
der Größer-als-Operator . In PowerShell wird dieses Zeichen für die Umleitung verwendet. Ausführliche Informationen finden Sie unter about_Redirection.
Wenn die linke Seite eine Auflistung ist, vergleichen diese Operatoren jedes Element der Auflistung mit der rechten Seite. Je nach Logik behalten sie den Member bei oder verwerfen es.
Beispiel:
$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
Diese Operatoren arbeiten mit jeder Klasse, die System.IComparable implementiert.
Beispiele:
# 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'
Das folgende Beispiel zeigt, dass auf einer amerikanischen QWERTY-Tastatur kein Symbol vorhanden ist, das nach "a" sortiert wird. Sie speist einen Satz, der alle derartigen Symbole enthält, an den -gt
Operator, um sie mit "a" zu vergleichen. Die Ausgabe ist ein leeres Array.
$a=' ','`','~','!','@','#','$','%','^','&','*','(',')','_','+','-','=',
'{','}','[',']',':',';','"','''','\','|','/','?','.','>',',','<'
$a -gt 'a'
# Output: Nothing
Wenn die beiden Seiten der Operatoren nicht angemessen vergleichbar sind, führen diese Operatoren zu einem nicht beendenden Fehler.
Übereinstimmende Operatoren
Die übereinstimmenden Operatoren (-like
, , -notlike
-match
und -notmatch
) suchen Nach Elementen, die einem angegebenen Muster entsprechen oder nicht. Das Muster für -like
und -notlike
ist ein Platzhalterausdruck (mit *
, ?
und [ ]
), während -match
und -notmatch
einen regulären Ausdruck (Regex) akzeptiert wird.
Die Syntax ist:
<string[]> -like <wildcard-expression>
<string[]> -notlike <wildcard-expression>
<string[]> -match <regular-expression>
<string[]> -notmatch <regular-expression>
Wenn die Eingabe dieser Operatoren ein skalarer Wert ist, geben sie einen booleschen Wert zurück. Wenn es sich bei der Eingabe um eine Auflistung von Werten handelt, geben die Operatoren alle übereinstimmenden Member zurück. Wenn keine Übereinstimmungen in einer Auflistung vorhanden sind, geben die Operatoren ein leeres Array zurück.
-like und -notlike
-like
und -notlike
verhalten sich ähnlich wie -eq
und -ne
, aber die rechte Seite könnte eine Zeichenfolge sein, die Wildcards enthält.
Beispiel:
"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 und -notmatch
-match
und -notmatch
verwenden Sie reguläre Ausdrücke, um in den linken Werten nach Mustern zu suchen. Reguläre Ausdrücke können mit komplexen Mustern wie E-Mail-Adressen, UNC-Pfaden oder formatierten Telefonnummern übereinstimmen. Die rechtsseitige Zeichenfolge muss den Regeln für reguläre Ausdrücke entsprechen.
Skalare Beispiele:
# 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
Wenn es sich bei der Eingabe um eine Auflistung handelt, geben die Operatoren die übereinstimmenden Member dieser Auflistung zurück.
Sammlungsbeispiele:
"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
und -notmatch
unterstützen Regex-Erfassungsgruppen. Jedes Mal, wenn sie mit skalarer Eingabe ausgeführt werden und das -match
Ergebnis True oder das -notmatch
Ergebnis False ist, überschreiben sie die $Matches
automatische Variable. $Matches
ist eine Hashtabelle , die immer über einen Schlüssel namens "0" verfügt, der die gesamte Übereinstimmung speichert.
Wenn der reguläre Ausdruck Erfassungsgruppen enthält, enthält der $Matches
zusätzliche Schlüssel für jede Gruppe.
Es ist wichtig zu beachten, dass die $Matches
Hashtabelle nur das erste Vorkommen eines übereinstimmenden Musters enthält.
Beispiel:
$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
Wenn das -match
Ergebnis False ist oder das -notmatch
Ergebnis True ist, oder wenn die Eingabe eine Auflistung ist, wird die $Matches
automatische Variable nicht überschrieben. Folglich enthält sie den zuvor festgelegten Wert, oder $null
wenn die Variable nicht festgelegt wurde. Wenn Sie nach dem Aufrufen eines dieser Operatoren $Matches
auf verweisen, sollten Sie überprüfen, ob die Variable durch den aktuellen Operatoraufruf mithilfe einer Condition-Anweisung festgelegt wurde.
Beispiel:
if ("<version>1.0.0</version>" -match '<version>(.*?)</version>') {
$Matches
}
Ausführliche Informationen finden Sie unter about_Regular_Expressions und about_Automatic_Variables.
Ersatzoperator
Ersetzen durch reguläre Ausdrücke
Wie -match
verwendet der -replace
Operator reguläre Ausdrücke, um das angegebene Muster zu finden. Im Gegensatz werden -match
die Übereinstimmungen jedoch durch einen anderen angegebenen Wert ersetzt.
Syntax:
<input> -replace <regular-expression>, <substitute>
Der Operator ersetzt einen Wert ganz oder teilweise durch den angegebenen Wert mithilfe regulärer Ausdrücke. Sie können den Operator für viele administrative Aufgaben verwenden, z. B. das Umbenennen von Dateien. Der folgende Befehl ändert beispielsweise die Dateinamenerweiterungen aller .txt
Dateien in .log
:
Get-ChildItem *.txt | Rename-Item -NewName { $_.name -replace '\.txt$','.log' }
Standardmäßig wird beim -replace
Operator die Groß-/Kleinschreibung nicht beachtet. Verwenden Sie -creplace
, um die Groß-/Kleinschreibung zu berücksichtigen. Verwenden Sie , um die Groß-/Kleinschreibung explizit zu berücksichtigen -ireplace
.
Beispiele:
"book" -ireplace "B", "C" # Case insensitive
"book" -creplace "B", "C" # Case-sensitive; hence, nothing to replace
Cook
book
Ersetzung regulärer Ausdrücke
Es ist auch möglich, reguläre Ausdrücke zu verwenden, um Text mithilfe von Erfassungsgruppen und Ersetzungen dynamisch zu ersetzen. Auf Erfassungsgruppen kann in der <substitute>
Zeichenfolge mit dem Dollarzeichen ($
) vor dem Gruppenbezeichner verwiesen werden.
Im folgenden Beispiel akzeptiert der -replace
Operator einen Benutzernamen in Form von DomainName\Username
und konvertiert in das Username@DomainName
Format:
$SearchExp = '^(?<DomainName>[\w-.]+)\\(?<Username>[\w-.]+)$'
$ReplaceExp = '${Username}@${DomainName}'
'Contoso.local\John.Doe' -replace $SearchExp, $ReplaceExp
John.Doe@Contoso.local
Warnung
Das $
Zeichen verfügt sowohl in PowerShell als auch in regulären Ausdrücken über syntaktische Rollen:
- In PowerShell bezeichnet er zwischen doppelten Anführungszeichen Variablen und fungiert als Unterausdruckoperator.
- In Regex-Suchzeichenfolgen bezeichnet es das Ende der Zeile.
- In Regex-Ersetzungszeichenfolgen werden erfasste Gruppen bezeichnet. Stellen Sie sicher, dass Sie Ihre regulären Ausdrücke entweder zwischen einzelnen Anführungszeichen platzieren oder ein Backtickzeichen (
`
) davor einfügen.
Beispiel:
$1 = 'Goodbye'
'Hello World' -replace '(\w+) \w+', "$1 Universe"
# Output: Goodbye Universe
'Hello World' -replace '(\w+) \w+', '$1 Universe'
# Output: Hello Universe
$$
in Regex bezeichnet ein Literal $
. Dies $$
in der Ersetzungszeichenfolge, um ein Literal $
in die resultierende Ersetzung einzuschließen. Beispiel:
'5.72' -replace '(.+)', '$ $1' # Output: $ 5.72
'5.72' -replace '(.+)', '$$$1' # Output: $5.72
'5.72' -replace '(.+)', '$$1' # Output: $1
Weitere Informationen finden Sie unter about_Regular_Expressions und Ersetzungen in regulären Ausdrücken.
Ersetzen in einer Auflistung
Wenn der <input>
auf den -replace
Operator eine Auflistung ist, wendet PowerShell die Ersetzung auf jeden Wert in der Auflistung an. Beispiel:
"B1","B2","B3","B4","B5" -replace "B", 'a'
a1
a2
a3
a4
a5
Ersetzen durch einen Skriptblock
In PowerShell 6 und höher akzeptiert der -replace
Operator auch einen Skriptblock, der die Ersetzung ausführt. Der Skriptblock wird für jede Übereinstimmung einmal ausgeführt.
Syntax:
<String> -replace <regular-expression>, {<Script-block>}
Verwenden Sie im Skriptblock die $_
automatische Variable, um auf den ersetzten Eingabetext und andere nützliche Informationen zuzugreifen. Der Klassentyp dieser Variablen ist System.Text.RegularExpressions.Match.
Im folgenden Beispiel werden jede Sequenz von drei Ziffern durch die Zeichenäquivalente ersetzt. Der Skriptblock wird für jeden Satz von drei Ziffern ausgeführt, die ersetzt werden müssen.
"072101108108111" -replace "\d{3}", {return [char][int]$_.Value}
Hello
Containmentoperatoren
Die Containmentoperatoren (-contains
, , -notcontains
-in
und -notin
) ähneln den Gleichheitsoperatoren, mit der Ausnahme, dass sie immer einen booleschen Wert zurückgeben, auch wenn es sich bei der Eingabe um eine Auflistung handelt. Diese Operatoren beenden den Vergleich, sobald sie die erste Übereinstimmung erkennen, während die Gleichheitsoperatoren alle Eingabemember auswerten. In einer sehr großen Auflistung geben diese Operatoren schneller zurück als die Gleichheitsoperatoren.
Syntax:
<Collection> -contains <Test-object>
<Collection> -notcontains <Test-object>
<Test-object> -in <Collection>
<Test-object> -notin <Collection>
-contains und -notcontains
Diese Operatoren geben an, ob eine Gruppe ein bestimmtes Element enthält. -contains
gibt True zurück, wenn die rechte Seite (Testobjekt) einem der Elemente im Satz entspricht. -notcontains
gibt stattdessen False zurück. Wenn es sich beim Testobjekt um eine Auflistung handelt, verwenden diese Operatoren Verweisgleichheit, d. h. sie überprüfen, ob eines der Elemente der Gruppe dasselbe instance des Testobjekts ist.
Beispiele:
"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
Komplexere Beispiele:
$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 und -notin
Die -in
Operatoren und -notin
wurden in PowerShell 3 als syntaktische Umkehrung der Operatoren und -contains
-notcontains
eingeführt. -in
gibt True zurück, wenn die linke Seite <test-object>
mit einem der Elemente in der Gruppe übereinstimmt. -notin
gibt stattdessen False zurück. Wenn das Testobjekt ein Satz ist, verwenden diese Operatoren Verweisgleichheit, um zu überprüfen, ob eines der Elemente der Gruppe dasselbe instance des Testobjekts ist.
Die folgenden Beispiele machen das gleiche wie die Beispiele für -contains
und -notcontains
tun, aber sie werden stattdessen mit -in
und -notin
geschrieben.
"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
Komplexere Beispiele:
$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
Typvergleich
Die Typvergleichsoperatoren (-is
und -isnot
) werden verwendet, um zu bestimmen, ob ein Objekt ein bestimmter Typ ist.
Syntax:
<object> -is <type-reference>
<object> -isnot <type-reference>
Beispiel:
$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