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 suchen, die mit angegebenen Mustern übereinstimmen. PowerShell umfasst die folgenden Vergleichsoperatoren:

Typ Operator Vergleichstest
Gleichheit -eq equals
-ne nicht gleich
-gt Größer als
-ge Größer als oder gleich
-lt Kleiner als
-le Kleiner als oder gleich
Matching -like Zeichenfolge entspricht Platzhaltermuster
-notlike Zeichenfolge entspricht nicht Platzhaltermuster
-match Zeichenfolge entspricht RegEx-Muster
-notmatch Zeichenfolge entspricht nicht regex-Muster
Ersetzung -replace ersetzt Zeichenfolgen, die einem RegEx-Muster entsprechen.
Containment -contains Sammlung enthält einen -Wert.
-notcontains Sammlung enthält keinen Wert
-in value befindet sich in einer Auflistung.
-notin value ist nicht in einer Auflistung
Typ -is Beide Objekte sind vom gleichen Typ.
-isnot Die Objekte sind nicht vom gleichen Typ.

Allgemeine Funktionen

Standardmäßig wird bei allen Vergleichsoperatoren die Groß-/Kleinschreibung nicht beachtet. Damit bei einem Vergleichsoperator die Schreibung beachtet wird, fügen Sie nach c - hinzu. Ist z. -ceq B. die Version von , bei der die Schreibung beachtet -eq wird. Um die Groß-/Kleinschreibung explizit zu machen, fügen Sie vor i - hinzu. Ist z. B. die version von , bei der die -ieq Groß-/Kleinschreibung explizit nicht beachtet -eq wird.

Wenn die Eingabe eines Operators ein Skalarwert ist, gibt der Operator einen booleschen Wert zurück. Wenn die Eingabe eine Auflistung ist, gibt der Operator die Elemente der Auflistung zurück, die mit dem rechten Wert des Ausdrucks übereinstimmen. Wenn keine Übereinstimmungen in der Auflistung 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 Type-Operatoren geben immer einen booleschen Wert zurück.
  • Der -replace Operator gibt das Ersetzungsergebnis zurück.
  • Die -match -notmatch Operatoren und füllen auch die automatische Variable auf, es sei denn, die linke Seite des Ausdrucks $Matches ist eine Auflistung.

Gleichheitsoperatoren

-eq und -ne

Wenn die linke Seite skalar ist, gibt True zurück, wenn die rechte Seite eine genaue Übereinstimmung -eq ist, andernfalls -eq false. -ne führt das Gegenteil aus; gibt FALSE zurück, wenn beide Seiten übereinstimmen. andernfalls -ne gibt True zurück.

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, die mit der rechten Seite -eq übereinstimmen, 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

Die Gleichheitsoperatoren akzeptieren zwei beliebige Objekte, nicht nur einen Skalar oder eine Auflistung. Das Vergleichsergebnis ist jedoch für den Endbenutzer nicht garantiert aussagekräftig. Im folgenden Beispiel wird das Problem veranschaulicht.

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 Ergebnis des Gleichheitstests 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 die File- und Size-Eigenschaften von zwei MyFileInfoSet-Objekten identisch sind.

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 es, herauszufinden, ob sie NULL sind. Wenn Sie jedoch bestimmen müssen, ob eine Variable ist, müssen Sie auf der linken Seite des $null $null Gleichheitsoperator setzen. Wenn Sie ihn auf der rechten Seite setzen, funktioniert nicht das, was Sie erwarten.

Beispiel: Ein $a Array, das NULL-Elemente enthält:

$a = 1, 2, $null, 4, $null, 6

Die folgenden Tests sind $a nicht NULL.

$null -ne $a
True

Im Folgenden werden jedoch alle NULL-Elemente aus $a entfernt:

$a -ne $null # Output: 1, 2, 4, 6
1
2
4
6

-gt, -ge, -lt und -le

-gt, -ge -lt , und verhalten sich -le 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. Weitere Informationen finden Sie unter about_Redirection.

Wenn die linke Seite eine Auflistung ist, vergleichen diese Operatoren jedes Member der Auflistung mit der rechten Seite. Je nach Logik behalten sie den Member entweder bei oder verwerfen ihn.

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'

Im folgenden Beispiel wird veranschaulicht, dass es auf einer amerikanischen QWERTY-Tastatur kein Symbol gibt, das nach "a" sortiert wird. Es gibt eine Menge mit allen symbolen an den Operator weiter, -gt 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 Fehler ohne Abbruch.

Übereinstimmende Operatoren

Die übereinstimmenden Operatoren ( , , und ) suchen nach Elementen, die mit einem angegebenen Muster übereinstimmen -like -notlike oder nicht -match -notmatch übereinstimmen. Das Muster für -like und -notlike ist ein Platzhalterausdruck (mit * , und ), während und einen regulären Ausdruck ? [ ] -match -notmatch (Regex) akzeptieren.

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 Skalarwert ist, geben sie einen booleschen Wert zurück. Wenn die Eingabe eine Auflistung von Werten ist, geben die Operatoren alle übereinstimmenden Member zurück. Wenn keine Übereinstimmungen in einer Auflistung sind, geben die Operatoren ein leeres Array zurück.

-like und -notlike

-likeund verhalten sich ähnlich wie und , aber die rechte Seite könnte eine Zeichenfolge sein, -notlike -eq die -ne Platzhalter 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 reguläre Ausdrücke, um in den werten auf der linken Seite nach Mustern zu suchen. Reguläre Ausdrücke können mit komplexen Mustern wie E-Mail-Adressen, UNC-Pfaden oder formatierten Telefonnummern übereinstimmen. Die Zeichenfolge auf der rechten Seite muss den Regeln für reguläre Ausdrücke entsprechen.

Skalarbeispiele:

# 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 die Eingabe eine Auflistung ist, geben die Operatoren die übereinstimmenden Member dieser Auflistung zurück, und die $Matches automatische Variable ist $null .

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. Bei jeder Ausführung überschreiben sie die $Matches automatische Variable. Wenn <input> eine Auflistung ist, ist die Variable $Matches $null . $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, $Matches enthält zusätzliche Schlüssel für jede Gruppe.

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

Weitere Informationen finden Sie unter about_Regular_Expressions.

Ersatzoperator

Ersetzung durch reguläre Ausdrücke

Wie -match verwendet der Operator reguläre -replace Ausdrücke, um das angegebene Muster zu finden. Im Gegensatz -match zu ersetzt er jedoch die Übereinstimmungen durch einen anderen angegebenen Wert.

Syntax:

<input> -replace <regular-expression>, <substitute>

Der -Operator ersetzt einen Wert ganz oder teilweise mithilfe von regulären Ausdrücken durch den angegebenen Wert. Sie können den -Operator für viele administrative Aufgaben verwenden, z. B. das Umbenennen von Dateien. Mit dem folgenden Befehl werden z. B. die Dateinamenerweiterungen aller .txt Dateien in .log geändert:

Get-ChildItem *.txt | Rename-Item -NewName { $_.name -replace '\.txt$','.log' }

Standardmäßig wird beim -replace Operator die Groß-/Kleinschreibung nicht beachtet. Um die Schreibung zu achten, verwenden Sie -creplace . Damit die Groß-/Kleinschreibung explizit nicht beachtet wird, verwenden Sie -ireplace .

Beispiele:

"book" -ireplace "B", "C" # Case insensitive
"book" -creplace "B", "C" # Case-sensitive; hence, nothing to replace
Cook
book

Ersetzungen regulärer Ausdrücke

Es ist auch möglich, reguläre Ausdrücke zu verwenden, um Text dynamisch durch Erfassungsgruppen und Ersetzungen zu ersetzen. Auf Erfassungsgruppen kann in der Zeichenfolge mithilfe des <substitute> Dollarzeichens ( $ ) vor dem Gruppenbezeichner verwiesen werden.

Im folgenden Beispiel akzeptiert der Operator einen Benutzernamen in Form von -replace und konvertiert in das Format DomainName\Username Username@DomainName :

$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 werden zwischen doppelten Anführungszeichen Variablen angegeben und als Teilausdrucksoperator verwendet.
  • In Regex-Suchzeichenfolgen gibt sie das Ende der Zeile an.
  • In Regex-Ersetzungszeichenfolgen werden erfasste Gruppen bezeichnet. Stellen Sie sicher, dass Sie Ihre regulären Ausdrücke entweder zwischen einfachen Anführungszeichen setzen oder ein Backtickzeichen ( ` ) 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 gibt ein Literal $ an. Dies $$ in der Ersetzungszeichenfolge, um ein Literal $ in die resultierende Ersetzung ein schließen zu können. 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.

Substituieren in einer Sammlung

Wenn der für den -Operator eine Sammlung ist, wendet PowerShell den Ersatz auf <input> jeden Wert in der Auflistung -replace an. Beispiel:

"B1","B2","B3","B4","B5" -replace "B", 'a'
a1
a2
a3
a4
a5

Ersetzung durch einen Skriptblock

In PowerShell 6 und höher akzeptiert der Operator auch -replace einen Skriptblock, der den Ersatz ausführt. Der Skriptblock wird für jede Übereinstimmung einmal ausgeführt.

Syntax:

<String> -replace <regular-expression>, {<Script-block>}

Verwenden Sie innerhalb des Skriptblocks die automatische Variable, um auf den zu ersetzenden Eingabetext $_ und andere nützliche Informationen zu zugreifen. Der Klassentyp dieser Variablen ist System.Text.RegularExpressions.Match.

Im folgenden Beispiel wird jede Sequenz aus drei Ziffern durch die Zeichenentsprechungen 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

Containment-Operatoren

Die Containment-Operatoren ( , , und ) ähneln den Gleichheitsoperatoren, mit der Ausnahme, dass sie immer einen -contains -notcontains -in -notin booleschen Wert zurückgeben, auch wenn die Eingabe eine Auflistung ist. Diese Operatoren beenden den Vergleich, sobald sie die erste Übereinstimmung erkennen, während die Gleichheitsoperatoren alle Eingabemitglieder auswerten. In einer sehr großen Sammlung geben diese Operatoren schneller als die Gleichheitsoperatoren zurück.

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 Menge ein bestimmtes Element enthält. -contains gibt TRUE zurück, wenn die rechte Seite (Testobjekt) einem der Elemente in der Menge entspricht. -notcontains gibt stattdessen False zurück. Wenn das Testobjekt eine Auflistung ist, verwenden diese Operatoren Verweisgleichheit, d. h., sie überprüfen, ob eines der Elemente der Gruppe die gleiche Instanz 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 Operatoren und -in – wurden in PowerShell 3 als syntaktische Umkehrung der Operatoren notin und contains -notcontain eingeführt. -in gibt TRUE zurück, wenn die linke Seite <test-object> einem der Elemente in der Menge entspricht. -notin gibt stattdessen False zurück. Wenn das Testobjekt eine Menge ist, verwenden diese Operatoren Verweisgleichheit, um zu überprüfen, ob eines der Elemente der Gruppe die gleiche Instanz des Testobjekts ist.

In den folgenden Beispielen wird das gleiche wie in den Beispielen für und -contain -notcontain verwendet, 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 ( und ) werden verwendet, um zu -is -isnot 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

SIEHE AUCH