about_Comparison_Operators

Artikel
05/09/2024

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

Gleichheit

-eq, -ieq, -ceq - gleich
-ne, -ine, -cne - nicht gleich
-gt, -igt, -cgt - größer als
-ge, -ige, -cge - größer als oder gleich
-lt, -ilt, -clt - kleiner als
-le, -ile, -cle - kleiner oder gleich

Passende

-like, -ilike, -clike - Zeichenfolge stimmt mit Einem Wildcard-Muster überein
-notlike, -inotlike, -cnotlike - Zeichenfolge stimmt nicht mit Dem Wildcard-Muster überein
-match, -imatch, - -cmatch Zeichenfolge entspricht regex-Muster
-notmatch, -inotmatch, -cnotmatch – Zeichenfolge stimmt nicht mit regex-Muster überein

Ersatz

-replace, -ireplace, -creplace - ersetzt Zeichenfolgen, die einem Regex-Muster entsprechen

Containment

-contains, -icontains, -ccontains - Auflistung enthält einen Wert
-notcontains, -inotcontains, -cnotcontains - Auflistung enthält keinen Wert
-in - Wert befindet sich in einer Auflistung
-notin - Wert befindet sich nicht in einer Auflistung

Typ

-is - Beide Objekte sind derselbe Typ
-isnot - Die Objekte sind nicht derselbe Typ

Allgemeine Funktionen

Bei Zeichenfolgenvergleichen wird die Groß-/Kleinschreibung nicht beachtet, es sei denn, Sie verwenden den expliziten Operator, der die Groß-/Kleinschreibung beachtet. Um die Groß-/Kleinschreibung eines Vergleichsoperators zu berücksichtigen, fügen Sie nach dem -hinzuc. Bei der Version von z. -ceq B. wird die Groß-/Kleinschreibung berücksichtigt -eq. Um die Groß-/Kleinschreibung explizit zu machen, fügen Sie nach -hinzui. Beispielsweise -ieq ist die Explizite Nicht-Groß-/Kleinschreibung-Version von -eq.

Zeichenfolgenvergleiche verwenden InvariantCulture für Vergleiche, bei dem die Groß- und Kleinschreibung beachtet werden. Die Vergleiche erfolgen zwischen Unicode-Codepunkten und verwenden keine kulturspezifische Sortierungsreihenfolge. Die Ergebnisse sind unabhängig von der aktuellen Kultur identisch.

Wenn die Eingabe eines Operators ein skalarer Wert ist, gibt der Operator einen booleschen Wert zurück. Wenn es sich bei der Eingabe um eine Auflistung handelt, gibt der Operator die Elemente der Auflistung zurück, die dem rechten Wert des Ausdrucks entsprechen. 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 Containment- und Typoperatoren geben immer einen booleschen Wert zurück.
Der -replace Operator gibt das Ersatzergebnis zurück.
Die -match Operatoren und -notmatch füllen auch die $Matches automatische Variable auf, es sei denn, die linke Seite des Ausdrucks ist eine Auflistung.

Gleichheitsoperatoren

-eq und -ne

Wenn die linke Seite skalar ist, gibt True zurück, -eq wenn die rechte Seite äquivalent ist, -eq andernfalls False. -ne tut das Gegenteil; Es gibt False zurück, wenn beide Seiten gleichwertig sind. Andernfalls -ne wird True zurückgegeben.

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, -eq die der rechten Seite entsprechen, 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

Der Gleichheitsoperator kann Objekte unterschiedlicher Typen vergleichen. Es ist wichtig zu verstehen, dass der Wert auf der rechten Seite des Vergleichs zum Vergleich in den Typ des linksseitigen Werts konvertiert werden kann.

Beispielsweise wird die Zeichenfolge '1.0' in eine ganze Zahl konvertiert, um mit dem Wert 1verglichen zu werden. In diesem Beispiel wird zurückgegeben True.

PS> 1 -eq '1.0'
True

In diesem Beispiel wird der Wert 1 in eine Zeichenfolge konvertiert, um mit Zeichenfolge '1.0'verglichen zu werden. In diesem Beispiel wird zurückgegeben False.

PS> '1.0' -eq 1
False

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. Das folgende Beispiel veranschaulicht das Problem.

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 prominentes Beispiel für den Vergleich beliebiger Objekte ist die Ermittlung, ob sie NULL sind. Wenn Sie jedoch feststellen müssen, ob eine Variable ist $null, müssen Sie auf der linken Seite des Gleichheitsoperators platzieren $null . Es auf der rechten Seite zu platzieren, ist nicht das, was Sie erwarten.

Lassen Sie uns $a beispielsweise 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 filern:$a

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

-gt, -ge, -lt und -le

-gt, -ge, -ltund -le verhalten sich 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. Ausführliche Informationen finden Sie unter about_Redirection.

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

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'

Das folgende Beispiel zeigt, dass auf einer amerikanischen QWERTY-Tastatur kein Symbol vorhanden ist, das nach "a" sortiert wird. Sie speist einen Satz, der alle derartigen Symbole enthält, an den -gt Operator, 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, lösen diese Operatoren einen nicht beendenden Fehler aus.

Übereinstimmende Operatoren

Die übereinstimmenden Operatoren (-like, , -notlike-matchund -notmatch) finden Elemente, die mit einem angegebenen Muster übereinstimmen oder nicht übereinstimmen. Das Muster für -like und -notlike ist ein Platzhalterausdruck (mit *, ?und [ ]), während -match und -notmatch einen 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 es sich bei der Eingabe um eine Auflistung von Werten handelt, wird jedes Element in der Auflistung zum Vergleich in eine Zeichenfolge konvertiert. Die -match Operatoren und -notmatch geben alle übereinstimmenden bzw. nicht übereinstimmenden Member zurück. Die -like Operatoren und -notlike geben die Member jedoch als Zeichenfolgen zurück. Die für ein Element der Auflistung zurückgegebene Zeichenfolge von -like und -notlike ist die Zeichenfolge, die der Operator für den Vergleich verwendet und durch Umwandeln des Elements in eine Zeichenfolge abgerufen wird.

-like und -notlike

-like und -notlike verhalten sich ähnlich wie -eq und -ne, aber die rechte Seite kann eine Zeichenfolge sein, die Wildcards 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 Sie 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 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 es sich bei der Eingabe um eine Auflistung handelt, 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 mit Skalareingaben ausgeführt werden und das -match Ergebnis True oder das -notmatch Ergebnis False ist, überschreiben sie die $Matches automatische Variable. $Matches ist eine Hashtabelle , die immer über einen Schlüssel mit dem Namen "0" verfügt, der die gesamte Übereinstimmung speichert. Wenn der reguläre Ausdruck Erfassungsgruppen enthält, enthält der $Matches zusätzliche Schlüssel für jede Gruppe.

Es ist wichtig zu beachten, dass die $Matches Hashtabelle nur das erste Vorkommen eines übereinstimmenden Musters enthält.

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 oder das -notmatch Ergebnis True ist, oder wenn die Eingabe eine Sammlung 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 $Matches auf verweisen, sollten Sie überprüfen, ob die Variable durch den aktuellen Operatoraufruf mithilfe einer Bedingungsanweisung 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

Ersetzen durch reguläre Ausdrücke

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

Syntax:

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

Der Operator ersetzt einen Wert ganz oder teilweise durch den angegebenen Wert mithilfe regulärer Ausdrücke. Sie können den Operator für viele administrative Aufgaben verwenden, z. B. das Umbenennen von Dateien. Der folgende Befehl ändert beispielsweise die Dateinamenerweiterungen aller .txt Dateien in .log:

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

Standardmäßig wird beim -replace Operator die Groß-/Kleinschreibung nicht beachtet. Verwenden Sie , um die Groß-/Kleinschreibung zu berücksichtigen -creplace. Um die Groß-/Kleinschreibung explizit zu berücksichtigen, verwenden Sie -ireplace.

Beispiele:

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

Cook
book

Ab PowerShell 7.2 wird dieser Operand in eine Zeichenfolge konvertiert, wenn der linke Operand in einer -replace Operator-Anweisung keine Zeichenfolge ist. PowerShell führt eine kulturunabhängige Zeichenfolgenkonvertierung durch.

Wenn Ihre Kultur beispielsweise auf Französisch (fr) festgelegt ist, lautet 1,2die kulturabhängige Zeichenfolgenkonvertierung des Werts 1.2 .

Vor PowerShell 7.2:

PS> [cultureinfo]::CurrentCulture = 'fr'
PS> 1.2 -replace ','
12

In PowerShell 7.2 und höher:

PS> [cultureinfo]::CurrentCulture = 'fr'
PS> 1.2 -replace ','
1.2

Ersetzungen regulärer Ausdrücke

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

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

$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 festgelegt und als Teilausdruckoperator verwendet.
In Regex-Suchzeichenfolgen gibt er 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 (`) davor 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 bezeichnet ein Literal $. Dies $$ in der Ersetzungszeichenfolge, um ein Literal $ in die resultierende Ersetzung einzuschließen. 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> für den -replace Operator eine Sammlung 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

Ersetzen durch einen Skriptblock

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

Syntax:

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

Verwenden Sie im Skriptblock die $_ automatische Variable, um auf den ersetzten 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 entsprechenden Zeichen 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 Einschlussoperatoren (-contains, , -notcontains-inund -notin) ähneln den 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.

-contains und -notcontains

Syntax:

<Collection> -contains <scalar-object>
<Collection> -notcontains <scalar-object>

Diese Operatoren geben an, ob ein Satz ein bestimmtes Element enthält. -contains gibt True zurück, wenn die rechte Seite (Skalarobjekt) mit einem der Elemente im Satz übereinstimmt. -notcontains gibt stattdessen False zurück.

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

Wenn der rechte Operand eine Auflistung ist, konvertieren diese Operatoren den Wert in seine Zeichenfolgendarstellung, bevor er mit der linken Auflistung verglichen wird.

$a = "abc", "def"
"abc", "def", "ghi" -contains $a # Output: False

# The following statements are equivalent
$a, "ghi" -contains $a           # Output: True
"$a", "ghi" -contains $a         # Output: True
"abc def", "ghi" -contains $a    # Output: True

-in und -notin

Syntax:

<scalar-object> -in <Collection>
<scalar-object> -notin <Collection>

Die -in Operatoren und -notin wurden in PowerShell 3 als syntaktische Umkehrung der Operatoren von -contains und -notcontains eingeführt. -in gibt True zurück, wenn die linke Seite <scalar-object> mit einem der Elemente in der Auflistung übereinstimmt. -notin gibt stattdessen False zurück.

In den folgenden Beispielen wird dasselbe wie in den Beispielen für -contains und -notcontains ausgeführt, aber sie werden mit -in und -notin stattdessen 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

Wenn der linke Operand eine Auflistung ist, konvertieren diese Operatoren den Wert in seine Zeichenfolgendarstellung, bevor er mit der rechten Auflistung verglichen wird.

$a = "abc", "def"
$a -in "abc", "def", "ghi" # Output: False

# The following statements are equivalent
$a -in $a, "ghi"           # Output: True
$a -in "$a", "ghi"         # Output: True
$a -in "abc def", "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

Freigeben über

about_Comparison_Operators

Kurze Beschreibung

Lange Beschreibung

Allgemeine Funktionen

Gleichheitsoperatoren

-eq und -ne

-gt, -ge, -lt und -le

Übereinstimmende Operatoren

-like und -notlike

-match und -notmatch

Ersetzungsoperator

Ersetzen durch reguläre Ausdrücke

Ersetzungen regulärer Ausdrücke

Ersetzen in einer Auflistung

Ersetzen durch einen Skriptblock

Containment-Operatoren

-contains und -notcontains

-in und -notin

Typvergleich

Weitere Informationen

Zusätzliche Ressourcen