THEMA
about_Comparison_Operators
KURZBESCHREIBUNG
Beschreibt die Operatoren zum Vergleichen von Werten in Windows
PowerShell.
DETAILBESCHREIBUNG
Über Vergleichsoperatoren können Sie Bedingungen angeben, mit
denen Werte verglichen oder Werte gesucht werden, die bestimmte
Muster aufweisen. Zum Verwenden eines Vergleichsoperators geben
Sie die zu vergleichenden Werte mit einem Operator an, durch den
diese getrennt werden.
Standardmäßig wird bei Vergleichsoperatoren die Groß-/Kleinschreib
ung nicht beachtet. Wenn die Groß-/Kleinschreibung für einen
Vergleichsoperator beachtet werden soll, stellen Sie dem
Operatornamen ein "c" voran.
Beispielsweise lautet die Version von "-eq", bei der die
Groß-/Kleinschreibung beachtet wird, "-ceq". Wenn ausdrücklich
keine Unterscheidung der Groß-/Kleinschreibung gemacht werden
soll, stellen Sie dem Operator ein "i" voran. Beispielsweise
lautet die Version von "-eq", bei der die Groß-/Kleinschreibung
ausdrücklich nicht beachtet wird, "-ieq".
Alle Vergleichsoperatoren, mit Ausnahme der Kapselungsoperatoren
(-contains, -notcontains) sowie der Typoperatoren (-is, -isnot)
geben einen booleschen Wert zurück, wenn für den Operator (Wert
links vom Operator) ein einzelner Wert (ein Skalar) eingegeben
wird. Bei Eingabe einer Auflistung von Werten geben die
Kapselungs- und Typoperatoren alle übereinstimmenden Werte
zurück. Wenn in einer Auflistung keine Übereinstimmungen
vorhanden sind, geben diese Operatoren nichts zurück. Die
Kapselungsoperatoren und Typoperatoren geben immer einen
booleschen Wert zurück.
Windows PowerShell unterstützt folgende Vergleichsoperatoren:
-eq
Beschreibung: Gleich. Schließt einen identischen Wert ein.
Beispiel:
C:\PS> "abc", "def" -eq "abc"
abc
-ne
Beschreibung: Ungleich. Schließt einen anderen Wert ein.
Beispiel:
C:\PS> "abc", "def" -ne "abc"
def
-gt
Beschreibung: Größer als.
Beispiel:
C:\PS> 8 -gt 6
True
-ge
Beschreibung: Größer als oder gleich.
Beispiel:
C:\PS> 8 -ge 8
True
-lt
Beschreibung: Kleiner als.
Beispiel:
C:\PS> 8 -lt 6
False
-le
Beschreibung: Kleiner als oder gleich.
Beispiel:
C:\PS> 6 -le 8
True
-like
Beschreibung: Übereinstimmung mit dem Platzhalterzeichen (*).
Beispiel:
C:\PS> "Windows PowerShell" -like "*shell"
True
-notlike
Beschreibung: Stimmt nicht mit dem Platzhalterzeichen (*) überein.
Beispiel:
C:\PS> "Windows PowerShell" -notlike "*shell"
False
-match
Beschreibung: Stimmt mit einer Zeichenfolge mit regulären
Ausdrücken überein. Füllt bei einer Skalareingabe die
automatische Variable "$Matches" auf.
Beispiel:
C:\PS> "Sonntag" -match "Sonn"
True
C:\PS> $matches
Name Value
---- -----
0 Sonn
-notmatch
Beschreibung: Stimmt nicht mit einer Zeichenfolge überein.
Verwendet reguläre Ausdrücke.
Füllt bei einer Skalareingabe die automatische
Variable "$Matches" auf.
Beispiel:
C:\PS> "Sonntag" -notmatch "Sonn"
False
C:\PS> $matches
Name Value
---- -----
0 Sonn
-contains
Beschreibung: Kapselungsoperator. Schließt einen identischen
Wert ein, der kein Teil eines Werts ist. Gibt immer einen
booleschen Wert zurück.
Beispiel:
C:PS> "abc", "def" -contains "def"
True
-notcontains
Beschreibung: Kapselungsoperator. Schließt keinen identischen
Wert ein. Gibt immer booleschen Wert zurück.
Beispiel:
C:PS> "Windows", "PowerShell" -notcontains "Shell"
True
-replace
Beschreibung: Ersetzungsoperator. Ändert die angegebenen
Elemente eines Werts.
Beispiel:
C:\PS> "Get-Process" -replace "Get", "Stop"
Stop-Process
Gleichheitsoperatoren
Die Gleichheitsoperatoren (-eq, -ne) geben den Wert TRUE oder
die Treffer zurück, wenn mindestens ein Eingabewert mit dem
angegebenen Muster identisch ist. Das gesamte Muster muss mit
einem gesamten Wert übereinstimmen.
In den folgenden Beispielen werden die Auswirkungen des equal
to-Operators veranschaulicht:
C:PS> 1,2,3 -eq 2
2
C:PS> "PowerShell" -eq "Shell"
False
C:PS> "Windows", "PowerShell" -eq "Shell"
C:PS>
C:\PS> "abc", "def", "123" -eq "def"
def
Kapselungsoperatoren
Die Kapselungsoperatoren sind (-contains und -notcontains)
ähneln den Gleichheitsoperatoren. Die Kapselungsoperatoren
geben jedoch stets einen booleschen Wert zurück, selbst wenn
eine Auflistung eingegeben wird.
Anders als die Gleichheitsoperatoren geben die Kapselungsoperato
ren zudem einen Wert zurück, sobald die erste Übereinstimmung
erkannt wurde. Die Gleichheitsoperatoren werten alle Eingaben
aus und geben dann alle Übereinstimmungen in der Auflistung zurück.
In den folgenden Beispielen werden die Auswirkungen des
-contains-Operators veranschaulicht:
C:PS> 1,2,3 -contains 2
True
C:PS> "PowerShell" -contains "Shell"
False
C:PS> "Windows", "PowerShell" -contains "Shell"
False
C:\PS> "abc", "def", "123" -contains "def"
True
C:\PS> "true", "blau", "sechs" -contains "true"
True
Im folgenden Beispiel wird gezeigt, wie sich die Kapselungsopera
toren vom equal to-Operator unterscheiden. Die Kapselungsoperato
ren geben den Wert TRUE als erste Übereinstimmung zurück.
C:\PS> 1,2,3,4,5,4,3,2,1 -eq 2
2
2
C:\PS> 1,2,3,4,5,4,3,2,1 -contains 2
True
In einer sehr umfangreichen Auflistung gibt der -contains-Operat
or Ergebnisse schneller zurück als der equal to-Operator.
Suchoperatoren
Mit den Suchoperatoren (-match und -notmatch) werden mit
regulären Ausdrücken Elemente gesucht, die mit einem
angegebenen Muster übereinstimmen bzw. nicht übereinstimmen.
Die Syntax lautet wie folgt:
<string[]> -match <regulärer-Ausdruck>
<string[]> -notmatch <regulärer-Ausdruck>
In den folgenden Beispielen werden einige Verwendungsmöglichkeit
en des -match-Operators gezeigt:
C:\PS> "Windows", "PowerShell" -match ".shell"
PowerShell
C:\PS> (get-command get-member -syntax) -match "-view"
True
C:\PS> (get-command get-member -syntax) -notmatch "-path"
True
C:\PS> (get-content servers.txt) -match "^Server\d\d"
Server01
Server02
Mit den Suchoperatoren wird nur in Zeichenfolgen gesucht. In
Arrays von ganzen Zahlen oder anderen Objekten kann mit ihnen
nicht gesucht werden.
Mit dem -match-Operator und dem -notmatch-Operator füllen Sie die
automatische Variable "$Matches" auf, wenn die Eingabe (das Argument
links) für den Operator aus einem einzelnen Skalarobjekt besteht. Bei
Eingabe eines Skalars geben der -match-Operator und der
-notmatch-Operator einen booleschen Wert zurück und legen den Wert
der automatischen Variablen "$Matches" auf die übereinstimmenden
Komponenten des Arguments fest.
Bei Eingabe einer Auflistung geben der -match-Operator und der
-notmatch-Operator die entsprechenden Elemente dieser
Auflistung zurück, doch füllt der Operator die Variable
"$Matches" nicht auf.
Beispielsweise wird mit dem folgenden Befehl eine Auflistung
von Zeichenfolgen an den -match-Operator gesendet. Der
-match-Operator gibt die übereinstimmenden Elemente in der
Auflistung zurück. Die automatische Variable "$Matches" dabei
wird nicht aufgefüllt.
C:\PS > "Sonntag", "Montag", "Dienstag" -match "Sonn"
Sonntag
C:\PS> $matches
C:\PS>
Im Gegensatz dazu wird mit dem folgenden Befehl eine einzelne
Zeichenfolge an den Suchoperator gesendet. Der -match-Operator
gibt einen booleschen Wert zurück und füllt die automatische
Variable "$Matches" auf.
C:\PS> "Sonntag" -match "Sonn"
True
C:\PS> $matches
Name Value
---- -----
0 Sonn
Der -notmatch-Operator füllt bei Eingabe eines Skalars die
automatische Variable "$Matches" auf, und das Ergebnis ist
False, wenn eine Übereinstimmung erkannt wird.
C:\PS > "Sonntag" -notmatch-"Regen"
True
C:\PS> $matches
C:\PS>
C:\PS> "Sonntag" -notmatch "tag"
False
C:\PS> $matches
C:\PS>
Name Value
---- -----
0 tag
Ersetzungsoperator
Mit dem -replace-Operator wird ein Wert mit regulären
Ausdrücken ganz oder teilweise durch den angegebenen Wert
ersetzt. Sie können den -replace-Operator für zahlreiche
Verwaltungsaufgaben verwenden, z. B. zum Umbenennen von
Dateien. Mit dem folgenden Befehl werden z. B. die
Dateinamenerweiterungen aller GIF-Dateien in ".jpg" geändert:
Get-ChildItem | Rename-Item -NewName { $_ -replace '.gif$','.jpg$' }
Für den -replace-Operator wird die folgende Syntax verwendet,
wobei der Platzhalter <ursprünglich> die zu ersetzenden Zeichen
und der Platzhalter <Ersatz> die Ersatzzeichen
darstellt:
<Eingabe> <Operator> <ursprünglich>, <Ersatz>
Standardmäßig wird beim -replace-Operator die Groß-/Kleinschreib
ung nicht beachtet. Wenn die Groß-/Kleinschreibung beachtet
werden soll, verwenden Sie -creplace. Wenn die Groß- und
Kleinschreibung ausdrücklich nicht beachtet werden soll,
verwenden Sie ireplace. Betrachten Sie die folgenden Beispiele:
C:\PS> "buchen" -replace "B", "S"
suchen
C:\PS> "buchen" -ireplace "B", "S"
suchen
C:\PS> "buchen" -creplace "B", "S"
buchen
Bitweise Operatoren
Windows PowerShell unterstützt die standardmäßigen bitweisen
Operatoren, einschließlich des bitweisen UND-Operators (-band)
und der inklusiven und exklusiven bitweisen ODER-Operatoren
(-bor und -bxor). Ab Windows PowerShell 2.0 werden für alle
bitweisen Operatoren 64-Bit-Ganzzahlen verwendet.
Windows PowerShell unterstützt die folgenden bitweisen Operatoren.
Operator Beschreibung Beispiel
-------- ---------------------- -------------------
-band Bitweises AND C:\PS> 10 -band 3
2
-bor Bitweises ODER (inklusiv) C:\PS> 10 -bor 3
11
-bxor Bitweises ODER (exklusiv) C:\PS> 10 -bxor 3
9
Bitweise Operatoren wirken sich auf das Binärformat eines Werts
aus. So lautet die Bitstruktur für die Zahl 10 wie folgt:
00001010 (basierend auf 1 Byte). Die Bitstruktur für die Zahl 3
lautet: 00000011. Wenn Sie einen bitweisen Operator verwenden,
um 10 mit 3 zu vergleichen, werden die einzelnen Bits in jedem
Byte verglichen.
In einer bitweisen UND-Operation wird das resultierende Bit nur
auf 1 festgelegt, wenn beide Eingabebits 1 sind.
00001010 (10)
00000011 ( 3)
------------------ Bitweises UND
00000010 ( 2)
In einer bitweisen ODER-Operation (inklusiv) wird das
resultierende Bit auf 1 festgelegt, wenn mindestens ein
Eingabebit 1 ist. Das resultierende Bit wird nur auf 0
festgelegt, wenn beide Eingabebits auf 0 festgelegt sind.
00001010 (10)
00000011 ( 3)
------------------ Bitweises ODER (inklusiv)
00001011 (11)
In einer bitweisen ODER-Operation (exklusiv) wird das
resultierende Bit nur auf 1 festgelegt, wenn eines der
Eingangbits 1 ist.
00001010 (10)
00000011 ( 3)
------------------ Bitweises ausschließendes ODER (exklusiv)
00001001 ( 9)
SIEHE AUCH
about_Operators
about_Regular_Expressions
about_Wildcards
Compare-Object