Share via


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