about_Comparison_Operators
Letzte Aktualisierung: Mai 2014
Betrifft: Windows PowerShell 2.0, Windows PowerShell 3.0, Windows PowerShell 4.0, Windows PowerShell 5.0
Einführung hier einfügen.
THEMA
about_Comparison_Operators
KURZE BESCHREIBUNG
Beschreibt die Operatoren für den Vergleich von Werten in Windows PowerShell®.
LANGE BESCHREIBUNG
Mit Vergleichsoperatoren können Sie Bedingungen für den Vergleich von Werten und die Suche nach Werten festlegen, die mit angegebenen Mustern übereinstimmen. Zur Verwendung eines Vergleichsoperators geben Sie die Werte, die Sie vergleichen möchten, und dazwischen den betreffenden Vergleichsoperator ein.
Windows PowerShell stellt die folgenden Vergleichsoperatoren bereit:
-eq
-ne
-gt
-ge
-lt
-le
-Like
-NotLike
-Match
-NotMatch
-Contains
-NotContains
-In
-NotIn
-Replace
Standardmäßig wird bei allen Vergleichsoperatoren die Groß-/Kleinschreibung ignoriert. Wenn auch die Schreibweise beachtet werden soll, stellen Sie dem Namen des Operators ein "c" voran. Die schreibweisensensible Version von "-Eq" lautet zum Beispiel "-Ceq". Um die Ignorierung der Schreibweise explizit hervorzuheben, stellen Sie dem Namen des Operators ein "i" voran. Die schreibweiseninsensible Version von "-eq" lautet zum Beispiel "-ieq".
Wenn die Eingabe eines Vergleichsoperators ein Skalarobjekt ist, gibt der Operator einen booleschen Wert zurück. Wenn die Eingabe eine Datengruppe ist, gibt der Vergleichsoperator alle übereinstimmenden Werte zurück. Wenn die Datengruppe keine Übereinstimmungen enthält, ist die Rückgabe des Vergleichsoperators leer.
Ausnahmen hiervon sind die Einschlussoperatoren (-Contains, -NotContains), die In-Operatoren (-In, -NotIn) und die Typoperatoren (-Is, -IsNot), die immer einen booleschen Wert zurückgeben.
Windows PowerShell unterstützt die folgenden Vergleichsoperatoren.
-eq
Beschreibung: Gleich. Enthält einen identischen Wert.
Beispiel:
PS C:\> "abc" -eq "abc"
True
PS C:\> "abc" -eq "abc", "def"
False
PS C:\> "abc", "def" -eq "abc"
abc
-ne
Beschreibung: Nicht gleich. Enthält einen anderen Wert.
Beispiel:
PS C:\> "abc" -ne "def"
True
PS C:\> "abc" -ne "abc"
False
PS C:\> "abc" -ne "abc", "def"
True
PS C:\> "abc", "def" -ne "abc"
def
-gt
Beschreibung: Größer als.
Beispiel:
PS C:\> 8 -gt 6
True
PS C:\> 7, 8, 9 -gt 8
9
-ge
Beschreibung: Größer als oder gleich.
Beispiel:
PS C:\> 8 -ge 8
True
PS C:\> 7, 8, 9 -ge 8
8
9
-lt
Beschreibung: Kleiner als.
Beispiel:
PS C:\> 8 -lt 6
False
PS C:\> 7, 8, 9 -lt 8
7
-le
Beschreibung: Kleiner als oder gleich.
Beispiel:
PS C:\> 6 -le 8
True
PS C:\> 7, 8, 9 -le 8
7
8
-Like
Beschreibung: Übereinstimmung mit dem Platzhalterzeichen (*).
Beispiel:
PS C:\> "Windows PowerShell" -like "*shell"
True
PS C:\> "Windows PowerShell", "Server" -like "*shell"
Windows PowerShell
-NotLike
Beschreibung: Keine Übereinstimmung mit dem Platzhalterzeichen (*).
Beispiel:
PS C:\> "Windows PowerShell" -NotLike "*shell"
False
PS C:\> "Windows PowerShell", "Server" -NotLike "*shell"
Server
-Match
Beschreibung: Sucht eine Übereinstimmung mit einer Zeichenfolge mithilfe regulärer Ausdrücke. Wenn die Eingabe ein Skalarobjekt ist, wird dessen Wert in die automatische Variable $Matches übertragen.
Beispiel:
PS C:\> "Sunday" -Match "sun"
True
PS C:\> $matches
Name Value
---- -----
0 Sun
PS C:\> "Sunday", "Monday" -Match "sun"
Sunday
-NotMatch
Beschreibung: Sucht eine Nichtübereinstimmung mit einer Zeichenfolge. mithilfe regulärer Ausdrücke. Wenn die Eingabe ein Skalarobjekt ist, wird dessen Wert in die automatische Variable $Matches übertragen.
Beispiel:
PS C:\> "Sunday" -NotMatch "sun"
False
PS C:\> $matches
Name Value
---- -----
0 sun
PS C:\> "Sunday", "Monday" -NotMatch "sun"
Monday
-Contains
Beschreibung: Einschlussoperator. Überprüft, ob eine Datengruppe mit Referenzwerten einen bestimmten Testwert enthält. Gibt immer einen booleschen Wert zurück. Gibt nur dann "true" zurück, wenn mindestens ein Referenzwert mit dem Testwert übereinstimmt.
Wenn der Testwert eine Datengruppe ist, gilt für den Operator -Contains Referenzgleichheit. Er gibt in diesem Fall nur dann "true" zurück, wenn einer der Referenzwerte die gleiche Instanz wie das Testwertobjekt ist.
Syntax:
<Reference-values> -Contains <Test-value>
Beispiele:
PS C:\> "abc", "def" -Contains "def"
True
PS C:\> "Windows", "PowerShell" -Contains "Shell"
False #Not an exact match
# Does the list of computers in $domainServers
# include $thisComputer?
# -------------------------------------------
PS C:\> $domainServers -Contains $thisComputer
True
PS C:\> "abc", "def", "ghi" -Contains "abc", "def"
False
PS C:\> $a = "abc", "def"
PS C:\> "abc", "def", "ghi" -Contains $a
False
PS C:\> $a, "ghi" -Contains $a
True
-NotContains
Beschreibung: Einschlussoperator. Überprüft, ob eine Datengruppe mit Referenzwerten einen bestimmten Testwert enthält. Gibt immer einen booleschen Wert zurück. Gibt nur dann "true" zurück, wenn mindestens ein Referenzwert nicht mit dem Testwert übereinstimmt.
Wenn der Testwert eine Datengruppe ist, gilt für den Operator -NotContains Referenzgleichheit.
Syntax:
<Reference-values> -NotContains <Test-value>
Beispiele:
PS C:\> "Windows", "PowerShell" -NotContains "Shell"
True #Not an exact match
# Get cmdlet parameters, but exclude common parameters
function get-parms ($cmdlet)
{
$Common = "Verbose", "Debug", "WarningAction", "WarningVariable", `
"ErrorAction", "ErrorVariable", "OutVariable", "OutBuffer"
$allparms = (Get-Command $Cmdlet).parametersets | foreach {$_.Parameters} | `
foreach {$_.Name} | Sort-Object | Get-Unique
$allparms | where {$Common -NotContains $_ }
}
# Find unapproved verbs in the functions in my module
# -------------------------------------------
PS C:\> $ApprovedVerbs = Get-Verb | foreach {$_.verb}
PS C:\> $myVerbs = Get-Command -Module MyModule | foreach {$_.verb}
PS C:\> $myVerbs | where {$ApprovedVerbs -NotContains $_}
ForEach
Sort
Tee
Where
-In
Beschreibung: In-Operator. Überprüft, ob eine Datengruppe mit Referenzwerten einen Testwert enthält. Gibt immer einen booleschen Wert zurück. Gibt nur dann "true" zurück, wenn mindestens ein Referenzwert mit dem Testwert übereinstimmt.
Wenn der Testwert eine Datengruppe ist, gilt für den Operator -In Referenzgleichheit. Er gibt in diesem Fall nur dann "true" zurück, wenn einer der Referenzwerte die gleiche Instanz wie das Testwertobjekt ist.
Der In-Operator wurde in Windows PowerShell 3.0 eingeführt.
Syntax:
<Test-value> -in <Reference-values>
Beispiele:
PS C:\> "def" -in "abc", "def"
True
PS C:\> "Shell" -in "Windows", "PowerShell"
False #Not an exact match
PS C:\> "Windows" -in "Windows", "PowerShell"
True #An exact match
PS C:\> "Windows", "PowerShell" -in "Windows", "PowerShell", "ServerManager"
False #Using reference equality
PS C:\> $a = "Windows", "PowerShell"
PS C:\> $a -in $a, "ServerManager"
True #Using reference equality
# Does the list of computers in $domainServers
# include $thisComputer?
# -------------------------------------------
PS C:\> $thisComputer -in $domainServers
True
-NotIn
Beschreibung: NotIn-Operator. Überprüft, ob eine Datengruppe mit Referenzwerten einen Testwert enthält. Gibt immer einen booleschen Wert zurück. Gibt nur dann "true" zurück, wenn mindestens ein Referenzwert nicht mit dem Testwert übereinstimmt.
Wenn der Testwert eine Datengruppe ist, gilt für den Operator -In Referenzgleichheit. Er gibt in diesem Fall nur dann "true" zurück, wenn einer der Referenzwerte die gleiche Instanz wie das Testwertobjekt ist.
Der NotIn-Operator wurde in Windows PowerShell 3.0 eingeführt.
Syntax:
<Test-value> -NotIn <Reference-values>
Beispiele:
PS C:\> "def" -NotIn "abc", "def"
False
PS C:\> "ghi" -NotIn "abc", "def"
True
PS C:\> "Shell" -NotIn "Windows", "PowerShell"
True #Not an exact match
PS C:\> "Windows" -NotIn "Windows", "PowerShell"
False #An exact match
# Find unapproved verbs in the functions in my module
# -------------------------------------------
PS C:\> $ApprovedVerbs = Get-Verb | foreach {$_.verb}
PS C:\> $myVerbs = Get-Command -Module MyModule | foreach {$_.verb}
PS C:\> $myVerbs | where {$_ -NotIn $ApprovedVerbs}
ForEach
Sort
Tee
Where
-Replace
Beschreibung: Ersetzungsoperator. Ändert die angegebenen Elemente eines Werts.
Beispiel:
PS C:\> "Get-Process" -Replace "Get", "Stop"
Stop-Process
# Change all .GIF file name extension to .JPG
PS C:\> dir *.gif | foreach {$_ -Replace ".gif", ".jpg"}
GLEICHHEITSOPERATOREN
Die Gleichheitsoperatoren (-eq, -ne) geben "true" bzw. die Übereinstimmungen zurück, wenn mindestens einer der Eingabewerte identisch mit dem angegebenen Muster ist. Dabei muss der gesamte Wert mit dem gesamten Muster übereinstimmen.
C:PS> 2 -eq 2
True
C:PS> 2 -eq 3
False
C:PS> 1,2,3 -eq 2
2
C:PS> "PowerShell" -eq "Shell"
False
C:PS> "Windows", "PowerShell" -eq "Shell"
C:PS>
PS C:\> "abc", "def", "123" -eq "def"
def
PS C:\> "abc", "def", "123" -ne "def"
abc
123
EINSCHLUSSOPERATOREN
Die Einschlussoperatoren (-Contains und -NotContains) sind den Gleichheitsoperatoren sehr ähnlich. Allerdings geben die Einschlussoperatoren immer einen booleschen Wert zurück, auch wenn die Eingabe eine Datengruppe ist.
Außerdem geben die Einschlussoperatoren im Gegensatz zu den Gleichheitsoperatoren einen ermittelten Wert sofort zurück, sobald die erste Übereinstimmung gefunden wird. Die Gleichheitsoperatoren werten dagegen zunächst die gesamte Eingabe aus und geben erst danach alle Übereinstimmungen der Datengruppe zurück. Die folgenden Beispiele zeigen die Funktion des Operators -Contains:
C:PS> 1,2,3 -contains 2
True
C:PS> "PowerShell" -contains "Shell"
False
C:PS> "Windows", "PowerShell" -contains "Shell"
False
PS C:\> "abc", "def", "123" -contains "def"
True
PS C:\> "true", "blue", "six" -contains "true"
True
Das folgende Beispiel zeigt den Unterschied des Einschlussoperators -contains zum Gleichheitsoperator -eq. Der Einschlussoperator gibt bei der ersten Übereinstimmung "true" zurück.
PS C:\> 1,2,3,4,5,4,3,2,1 -eq 2
2
2
PS C:\> 1,2,3,4,5,4,3,2,1 -contains 2
True
In einer sehr großen Datengruppe gibt der Einschlussoperator (-contains) die Ergebnisse schneller zurück als der Gleichheitsoperator (-eq).
Abgleichoperatoren
Die Abgleichoperatoren (-Match und -NotMatch) suchen mithilfe regulärer Ausdrücke nach Elementen, die mit einem angegebenen Muster übereinstimmen bzw. nicht übereinstimmen.
Die Syntax lautet:
<string[]> -Match <regular-expression>
<string[]> -NotMatch <regular-expression>
Die folgenden Beispiele zeigen Verwendungsmöglichkeiten des Operators -Match:
PS C:\> "Windows", "PowerShell" -Match ".shell"
PowerShell
PS C:\> (Get-Command Get-Member -Syntax) -Match "-view"
True
PS C:\> (Get-Command Get-Member -Syntax) -NotMatch "-path"
True
PS C:\> (Get-Content Servers.txt) -Match "^Server\d\d"
Server01
Server02
Die Abgleichoperatoren durchsuchen nur Zeichenfolgen. Ganzzahlen-Arrays oder andere Objekte werden von diesen Operatoren nicht unterstützt.
Die Operatoren -Match und -NotMatch füllen die automatische Variable $Matches, wenn die Operatoreingabe (das Argument auf der linken Seite) ein einzelnes Skalarobjekt ist. Wenn die Eingabe ein Skalarobjekt ist, geben die Operatoren -Match und -NotMatch einen booleschen Wert zurück und setzen den Wert der automatischen Variablen $Matches auf die abgeglichenen Komponenten des Arguments.
Wenn die Eingabe eine Datengruppe ist, geben die Operatoren -Match und -NotMatch die übereinstimmenden Elemente der Datengruppe zurück, füllen aber nicht die automatische Variable $Matches.
Der folgende Befehl übergibt beispielsweise eine Datengruppe mit Zeichenfolgen an den Operator -Match. Der Operator -Match gibt die übereinstimmenden Elemente der Datengruppe zurück. Die automatische Variable $Matches füllt er nicht.
PS C:\> "Sunday", "Monday", "Tuesday" -Match "sun"
Sunday
PS C:\> $matches
PS C:\>
Der folgende Befehl übergibt dem Operator -Match dagegen eine einzelne Zeichenfolge. Der Operator -Match gibt einen booleschen Wert zurück und füllt die automatische Variable $Matches.
PS C:\> "Sunday" -Match "sun"
True
PS C:\> $matches
Name Value
---- -----
0 Sun
Der Operator -NotMatch füllt die automatische Variable $Matches, wenn die Eingabe ein Skalarobjekt und das Ergebnis "false" ist, d. h., wenn eine Übereinstimmung erkannt wurde.
PS C:\> "Sunday" -NotMatch "rain"
True
PS C:\> $matches
PS C:\>
PS C:\> "Sunday" -NotMatch "day"
False
PS C:\> $matches
PS C:\>
Name Value
---- -----
0 day
ERSETZUNGSOPERATOR
Der Operator -Replace ersetzt einen Wert mithilfe regulärer Ausdrücke ganz oder teilweise durch den angegebenen Wert. Damit eignet sich der Operator -Replace für zahlreiche Verwaltungsaufgaben wie z. B. das Umbenennen von Dateien. Der folgende Befehl ändert beispielsweise die Dateinamenerweiterung aller GIF-Dateien in .jpg:
Get-ChildItem | Rename-Item -NewName { $_ -Replace '.gif$','.jpg$' }
Die Syntax des Operators -Replace ist wie folgt. Der Platzhalter <original> steht dabei für die zu ersetzenden Zeichen und der Platzhalter <substitute> für die Zeichen, die die ursprünglichen Zeichen ersetzen:
<input> <operator> <original>, <substitute>
Standardmäßig wird die Groß-/Kleinschreibung beim Operator -Replace ignoriert. Wenn auch die Schreibweise beachtet werden soll, verwenden Sie -cReplace. Um die Ignorierung der Schreibweise explizit hervorzuheben, verwenden Sie -iReplace. Sehen Sie sich hierzu die folgenden Beispiele an:
PS C:\> "book" -Replace "B", "C"
Cook
PS C:\> "book" -iReplace "B", "C"
Cook
PS C:\> "book" -cReplace "B", "C"
book
PS C:\> '<command:parameter required="false" variableLength="true" globbing="false"'`
| foreach {$_ -replace 'globbing="false"', 'globbing="true"'}
<command:parameter required="false" variableLength="true" globbing="true"
Bitweise Operatoren
Windows PowerShell unterstützt die bitweisen Standardoperatoren wie das bitweise AND (-bAnd), die inklusiven und exklusiven bitweisen OR-Operatoren (-bOr und -bXor) und das bitweise NOT (-bNot).
Ab Windows PowerShell 2.0 funktionieren alle bitweisen Operatoren mit ganzzahligen 64-Bit-Werten.
Ab Windows PowerShell 3.0 unterstützen shr (shift-right = nach rechts verschieben) und -shl (shift-left = nach links verschieben) die bitweise Arithmetik auch in Windows PowerShell.
Windows PowerShell unterstützt die folgenden bitweisen Operatoren.
Operator Description Example
-------- ---------------------- -------------------
-bAnd Bitwise AND PS C:\> 10 -band 3
2
-bOr Bitwise OR (inclusive) PS C:\> 10 -bor 3
11
-bXor Bitwise OR (exclusive) PS C:\> 10 -bxor 3
9
-bNot Bitwise NOT PS C:\> -bNot 10
-11
-shl Shift-left PS C:\> 100 -shl 2
400
-shr Shift-right PS C:\> 100 -shr 1
50
Bitweise Operatoren agieren am binären Format eines Werts. Die Bit-Struktur der Zahl 10 beispielsweise lautet 00001010 (basierend auf 1 Byte) und die Bit-Struktur der Zahl 3 lautet 00000011. Wenn Sie einen bitweisen Operator zum Vergleich der Zahl 10 mit der Zahl 3 verwenden, werden die einzelnen Bits eines jeden Byte verglichen.
Bei einer bitweisen AND-Operation wird das Ausgabebit nur dann auf 1 gesetzt, wenn beide Eingabebits 1 sind.
1010 (10)
0011 ( 3)
-------------- bAND
0010 ( 2)
Bei einer inklusiven bitweisen OR-Operation wird das Ausgabebit auf 1 gesetzt, wenn eines oder beide der Eingabebits 1 sind. Das Ausgabebit wird also nur dann auf 0 gesetzt, wenn beide Eingabebits 0 sind.
1010 (10)
0011 ( 3)
-------------- bOR (inclusive)
1011 (11)
Bei einer exklusiven bitweisen OR-Operation wird das Ausgabebit nur dann auf 1 gesetzt, wenn nur eines der beiden Eingabebits 1 ist.
1010 (10)
0011 ( 3)
-------------- bXOR (exclusive)
1001 ( 9)
Der bitweise NOT-Operator ist ein unärer Operator, der das binäre Komplement (Gegenteil) des Werts ausgibt. Das Bit 1 wird also auf 0 gesetzt und das Bit 0 auf 1.
Das binäre Komplement von 0 ist beispielsweise -1 (der maximale Integerwert ohne Vorzeichen (0xffffffff)), und das binäre Komplement von -1 ist 0.
PS C:\> -bNOT 10
-11
0000 0000 0000 1010 (10)
------------------------- bNOT
1111 1111 1111 0101 (-11, xfffffff5)
Bei einer bitweisen Shift-left-Operation werden alle Bits um "n" Stellen nach links verschoben, wobei "n" der Wert des rechten Operanden ist. An Einerstellen wird eine 0 (null) eingefügt.
Wenn der linke Operand ein Integer-Wert (32-Bit) ist, bestimmen die unteren 5 Bits des rechten Operanden, wie viele Bits des linken Operanden verschoben werden.
Wenn der linke Operand ein Long-Wert (64-Bit) ist, bestimmen die unteren 6 Bits des rechten Operanden, wie viele Bits des linken Operanden verschoben werden.
PS C:\> 21 -shl 1
42
00010101 (21)
00101010 (42)
PS C:\> 21 -shl 2
84
00010101 (21)
00101010 (42)
01010100 (84)
Bei einer bitweisen Shift-right-Operation werden alle Bits um "n" Stellen nach rechts verschoben, wobei "n" durch den rechten Operanden bestimmt wird. Der Operator -shr fügt beim Verschieben eines positiven Werts bzw. eines Werts ohne Vorzeichen nach rechts auf der linken Seite die entsprechende Anzahl an Nullen ein.
Wenn der linke Operand ein Integer-Wert (32-Bit) ist, bestimmen die unteren 5 Bits des rechten Operanden, wie viele Bits des linken Operanden verschoben werden.
Wenn der linke Operand ein Long-Wert (64-Bit) ist, bestimmen die unteren 6 Bits des rechten Operanden, wie viele Bits des linken Operanden verschoben werden.
PS C:\> 21 -shr 1
10
00010101 (21)
00001010 (10)
PS C:\> 21 -shr 2
5
00010101 (21)
00001010 (10)
00000101 ( 5)
SIEHE AUCH
about_Operators
about_Regular_Expressions
about_Wildcards
Compare-Objekt
Foreach-Objekt
Where-Objekt