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 enthält die folgenden Vergleichsoperatoren:

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

Allgemeine Funktionen

Bei Zeichenfolgenvergleichen wird standardmäßig die Groß-/Kleinschreibung nicht beachtet. Die Gleichheitsoperatoren weisen explizite Groß-/Kleinschreibung und Groß-/Kleinschreibung nicht beachtende Formen auf. Um die Groß-/Kleinschreibung eines Vergleichsoperators zu beachten, fügen Sie c nach - hinzu. ist beispielsweise die Version von , -ceq bei der die Groß-/Kleinschreibung beachtet -eq wird. Um die Groß-/Kleinschreibung explizit zu machen, fügen Sie nach ein i - hinzu. ist beispielsweise -ieq die Version von , bei der die 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 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 Einschluss- und Typoperatoren geben immer einen booleschen Wert zurück.
  • Der -replace Operator gibt das Ersetzungsergebnis zurück.
  • Die Operatoren und füllen auch die automatische Variable auf, -match -notmatch es sei $Matches denn, die linke Seite des Ausdrucks ist eine Auflistung.

Gleichheitsoperatoren

-eq und -ne

Wenn die linke Seite skalar ist, -eq gibt True zurück, wenn die rechte Seite eine genaue Übereinstimmung ist. Andernfalls -eq wird False zurückgegeben. -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, -eq gibt die Elemente zurück, die mit der rechten Seite übereinstimmen, während -ne sie herausfiltert.

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. Es ist jedoch nicht garantiert, dass das Vergleichsergebnis für den Endbenutzer aussagekräftig ist. 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 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 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 wichtiges Beispiel für den Vergleich beliebiger Objekte ist die Ermittlung, ob sie NULL sind. Wenn Sie jedoch bestimmen müssen, ob eine Variable $null ist, müssen Sie $null auf der linken Seite des Gleichheitsoperators setzen. Wenn sie auf der rechten Seite angezeigt wird, ist dies nicht das, was Sie erwarten.

Lassen Sie uns beispielsweise $a ein Array sein, 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 filert:

$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 Je nach Vergleich der beiden Seiten True oder False zurück:

Operator 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 jeden Member der Auflistung mit der rechten Seite. Je nach Logik behalten oder verwerfen sie den Member.

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.IComparableimplementiert.

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. Es wird eine Gruppe mit allen solchen Symbolen an den Operator gespeist, -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 halbwegs vergleichbar sind, auslösen diese Operatoren einen Fehler ohne Abbruch.

Übereinstimmende Operatoren

Die übereinstimmenden Operatoren ( -like , , und ) suchen -notlike -match -notmatch Elemente, die mit einem angegebenen Muster übereinstimmen oder nicht übereinstimmen. Das Muster für -like und -notlike ist ein Platzhalterausdruck (mit * , und ), während und einen ? [ ] -match -notmatch regulären Ausdruck (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 vorhanden sind, geben die Operatoren ein leeres Array zurück.

-like und -notlike

-like und -notlike verhalten sich ähnlich wie und , aber die rechte Seite kann eine Zeichenfolge -eq -ne sein, die Platzhalterenthä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 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 rechte 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 die Eingabe eine Auflistung ist, 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 für skalare Eingaben ausgeführt werden und das -match Ergebnis True oder -notmatch 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, $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

Wenn das -match Ergebnis False ist, das -notmatch Ergebnis True oder 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 auf einen $Matches dieser Operatoren 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
}

Weitere Informationen finden Sie unter about_Regular_Expressions und about_Automatic_Variables.

Ersetzungsoperator

Ersetzung durch reguläre Ausdrücke

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

Syntax:

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

Der -Operator ersetzt einen Wert ganz oder teilweise mithilfe regulärer Ausdrücke 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 beispielsweise die Dateinamenerweiterungen aller .txt Dateien in .log geändert:

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

Standardmäßig wird beim Operator die -replace Groß-/Kleinschreibung nicht beachtet. Verwenden Sie , um die Groß-/Kleinschreibung zu -creplace beachten. Verwenden Sie , um die Groß-/Kleinschreibung explizit zu -ireplace achten.

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 <substitute> Zeichenfolge mithilfe des Dollarzeichens ( $ ) vor dem Gruppenbezeichner verwiesen werden.

Im folgenden Beispiel akzeptiert der -replace Operator einen Benutzernamen in der Form 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 syntatische Rollen:

  • In PowerShell werden zwischen doppelten Anführungszeichen Variablen festgelegt und als Teilausdrucksoperator fungiert.
  • In Regex-Suchzeichenfolgen steht dies für das Ende der Zeile.
  • In Regex-Ersetzungszeichenfolgen werden erfasste Gruppen bezeichnet. Stellen Sie sicher, dass Sie ihre regulären Ausdrücke entweder zwischen einfache Anführungszeichen setzen oder ein Backtickzeichen ` () vor ihnen 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 einzufügen. 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

Ersetzung durch einen Skriptblock

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

Syntax:

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

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

Im folgenden Beispiel wird jede Sequenz von 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

Einschlussoperatoren

Die Einschlussoperatoren ( -contains , , und ) ähneln den -notcontains -in -notin Gleichheitsoperatoren, mit der Ausnahme, dass sie immer einen 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 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 ein Satz ein bestimmtes Element enthält. -contains gibt True zurück, wenn die rechte Seite (Testobjekt) mit einem der Elemente im Satz übereinstimmt. -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 -in -notin Operatoren und wurden in PowerShell 3 als syntaktisches Gegenteil der -contains Operatoren und -notcontains eingeführt. -in gibt True zurück, wenn die linke Seite <test-object> mit einem der Elemente in der Menge ü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 die gleiche Instanz des Testobjekts ist.

In den folgenden Beispielen wird dasselbe wie in den Beispielen für -contains und -notcontains 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 ( -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

SIEHE AUCH