Über Vergleichsoperatoren

Kurzbeschreibung

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 den angegebenen Mustern entsprechen. PowerShell enthält 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 - weniger als
• -le, -ile, -cle - kleiner als oder gleich

Abgleich

• -like, -ilike, -clike: Zeichenfolge stimmt mit Platzhaltermuster überein
• -notlike, -inotlike, -cnotlike: Zeichenfolge stimmt nicht mit Platzhaltermuster überein
• -match, -imatch, -cmatch - Zeichenfolge entspricht regex-Muster
• -notmatch, -inotmatch, -cnotmatch – Zeichenfolge stimmt nicht mit dem regex-Muster überein.

Ersatz

• -replace, , - -ireplace-creplace sucht und ersetzt Zeichenfolgen, die einem regex-Muster entsprechen.

Eindämmung

• -contains, -icontains, -ccontains: Auflistung enthält einen Wert.
• -notcontains, -inotcontains, -cnotcontains: Auflistung enthält einen Wert nicht.
• -in, -iin, -cin: Der Wert ist in einer Sammlung enthalten
• -notin, -inotin, -cnotin: Der Wert ist nicht in einer Sammlung enthalten

Typ

• -is - beide Objekte sind derselbe Typ
• -isnot - die Objekte sind nicht derselbe Typ

Allgemeine Features

Bei Zeichenfolgenvergleichen wird die Groß-/Kleinschreibung nicht beachtet, es sei denn, Sie verwenden den expliziten Operator für Groß-/Kleinschreibung. Um festzulegen, dass bei einem Vergleichsoperator die Groß-/Kleinschreibung beachtet werden muss, fügen Sie c nach - hinzu. Beispielsweise ist -ceq die Version von -eq, bei der die Groß-/Kleinschreibung beachtet wird. Um die Groß-/Kleinschreibung explizit festzulegen, fügen Sie i nach - hinzu. Beispielsweise ist -ieq die Version von -eq, bei der die Groß-/Kleinschreibung explizit nicht beachtet wird.

Bei Zeichenfolgenvergleichen wird InvariantCulture für Vergleiche mit und ohne Groß- und Kleinschreibung verwendet. Die Vergleiche liegen zwischen Unicode-Codepunkten und verwenden keine kulturspezifische Sortierreihenfolge. Die Ergebnisse sind unabhängig von der aktuellen Kultur gleich.

Wenn der linke Wert im Vergleichsausdruck ein skalarer-Wert ist, gibt der Operator einen booleschen Wert zurück. Wenn der linke Wert im Ausdruck eine Auflistung ist, gibt der Operator die Elemente der Auflistung zurück, die dem rechten Wert des Ausdrucks entsprechen. Die Werte auf der rechten Seite werden immer wie Singleton-Instanzen behandelt, selbst wenn es sich dabei um Sammlungen handelt. Die Vergleichsoperatoren können Sammlungen nicht effektiv mit Sammlungen vergleichen.

Wenn in der Auflistung keine Übereinstimmungen vorhanden sind, geben Vergleichsoperatoren ein leeres Array zurück. Zum Beispiel:

$a = (1, 2) -eq 3
$a.GetType().Name
$a.Count

Object[]
0

Es gibt einige Ausnahmen:

• Die Einschluss- und Typoperatoren geben immer einen booleschen Wert zurück.
• Der -replace-Operator gibt das Ersetzungsergebnis zurück.
• Die Operatoren -match und -notmatch füllen auch die automatische Variable $Matches auf, es sei denn, die linke Seite des Ausdrucks ist eine Auflistung.

Gleichheitsoperatoren

-eq und -ne

Wenn die linke Seite ein Skalarwert ist, gibt -eqTrue zurück, wenn die rechte Seite gleichwertig ist, andernfalls gibt -eqFalse zurück. -ne macht das Gegenteil: False wird zurückgegeben, wenn beide Seiten gleichwertig sind. Andernfalls gibt -neTrue 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 es sich bei der linken Seite um eine Auflistung handelt, gibt -eq die Elemente zurück, die mit der rechten Seite übereinstimmen, während -ne sie aussortiert.

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 für den Vergleich in den Typ des Werts auf der linken Seite konvertiert werden kann.

Beispielsweise wird die Zeichenfolge '1.0' in eine ganze Zahl konvertiert, die mit dem Wert 1verglichen werden soll. Dieses Beispiel gibt True zurück.

PS> 1 -eq '1.0'
True

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

PS> '1.0' -eq 1
False

Die Gleichheitsoperatoren akzeptieren zwei beliebige Objekte, nicht nur einen Skalar oder eine Auflistung. Das Vergleichsergebnis ist jedoch nicht garantiert für den Endbenutzer 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 Gleichheitstestergebnis ist jedoch False, da sie unterschiedliche Objekte sind. Um vergleichbare Klassen zu erstellen, müssen Sie System.IEquatable<T> in Ihrer Klasse implementieren. Das folgende Beispiel veranschaulicht die partielle Implementierung einer MyFileInfoSet Klasse, die System.IEquatable<T> implementiert und zwei Eigenschaften aufweist, File und Size. Die Equals()-Methode gibt True zurück, wenn die Eigenschaften File und Size 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 besteht darin, herauszufinden, ob sie null sind. Wenn Sie jedoch bestimmen müssen, ob eine Variable $nullist, müssen Sie $null auf der linken Seite des Gleichheitsoperators platzieren. Wenn Sie das Element auf der rechten Seite platzieren, führt das nicht zum erwarteten Ergebnis.

Lassen Sie beispielsweise $a ein Array sein, das NULL-Elemente enthält:

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

Der folgende Test überprüft, dass $a nicht null ist.

$null -ne $a

True

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

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

1
2
4
6

-gt, -ge, -lt und -le

-gt, -ge, -ltund -le verhalten sich sehr ähnlich. Wenn beide Seiten skalar sind, geben sie entweder True oder False zurück, je nachdem, wie die beiden Seiten verglichen werden.

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

Wenn die linke Seite eine Sammlung ist, vergleichen diese Operatoren jedes Element der Auflistung mit der rechten Seite. Abhängig von ihrer Logik behalten oder verwerfen sie das Mitglied.

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 übergibt einen Satz mit allen derartigen Symbolen an den -gt-Operator, damit sie mit „a“ verglichen werden. Die Ausgabe ist ein leeres Array.

$a=' ','`','~','!','@','#','$','%','^','&','*','(',')','_','+','-','=',
   '{','}','[',']',':',';','"','''','\','|','/','?','.','>',',','<'
$a -gt 'a'
# Output: Nothing

Wenn die beiden Seiten der Operatoren nicht einigermaßen vergleichbar sind, lösen diese Operatoren einen Fehler ohne Abbruch aus.

Übereinstimmende Operatoren

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

Die Syntax lautet:

<string[]> -like    <wildcard-expression>
<string[]> -notlike <wildcard-expression>
<string[]> -match    <regular-expression>
<string[]> -notmatch <regular-expression>

Wenn die Eingabe dieser Operatoren ein skalarer Wert ist, geben sie einen booleschen Wert zurück.

Wenn es sich bei der Eingabe um eine Sammlung von Werten handelt, wird jedes Element in der Auflistung zum Vergleich in eine Zeichenfolge konvertiert. Die Operatoren -match und -notmatch geben jeweils alle übereinstimmenden und nicht übereinstimmenden Elemente zurück. Die Operatoren -like und -notlike geben die Elemente jedoch als Zeichenfolgen zurück. Die Zeichenfolge, die für ein Element der Auflistung von -like und -notlike zurückgegeben wird, ist die Zeichenfolge, die der Operator für den Vergleich verwendet hat. Sie wird durch Umwandeln des Elements in eine Zeichenfolge abgerufen.

-like und -notlike

-like und -notlike verhalten sich ähnlich wie -eq und -ne, aber die rechte Seite kann eine Zeichenfolge sein, die 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

Um optimale Ergebnisse zu erzielen, sollte die rechte Seite der -like Operatoren -notlike ein Zeichenfolgenliteral sein, das den Wildcardausdruck enthält. PowerShell übergibt den Platzhalterausdruck an den Parser für Platzhalterausdrücke. Um einem der Wildcardzeichen (*, oder ?) zu entsprechen, [ ]müssen Sie es mit einem Hintergrundzeichen (`) escapen. Verwenden Sie ? z. B. zum Abgleichen eines Literals `?im Wildcardausdruck. Wenn Sie einen erweiterbaren Zeichenfolgenausdruck verwenden, erweitert PowerShell die Zeichenfolge, bevor sie an den Platzhalterparser übergeben wird, was dazu führt, dass nicht gescapete Zeichen als Platzhalter gesendet werden.

# Escaped literals in an expandable string
PS> "f`?`?"
f??
# Escaped literals in a literal string
PS> 'f`?`?'
f`?`?
# Comparison containing 2 wildcards
PS> 'f??' -like 'f??'
True
PS> 'for' -like 'f??'
True
# Comparison containing literal '?' characters
PS> 'f??' -like 'f`?`?'
True
PS> 'for' -like 'f`?`?'
False

-match und -notmatch

-match und -notmatch verwenden reguläre Ausdrücke, um nach Mustern in den Werten auf der linken Seite zu suchen. Reguläre Ausdrücke können komplexe Muster wie E-Mail-Adressen, UNC-Pfade oder formatierte Telefonnummern abgleichen. 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 es sich bei der Eingabe um eine Auflistung handelt, geben die Operatoren die übereinstimmenden Elemente dieser Auflistung zurück.

Auflistungsbeispiele:

'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 Skalarwerteingaben ausgeführt werden und das -match-Ergebnis True oder das -notmatch-Ergebnis False ist, überschreiben sie die automatische Variable $Matches. $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, enthält $Matches zusätzliche Schlüssel für jede Gruppe.

Es ist wichtig zu beachten, dass die Hashtabelle $Matches 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 oder das -notmatch-Ergebnis True ist oder wenn die Eingabe eine Auflistung ist, wird die automatische Variable $Matches nicht überschrieben. Folglich enthält sie den zuvor festgelegten Wert oder $null, wenn die Variable nicht festgelegt wurde. Beim Verweisen auf $Matches nach dem Aufrufen eines dieser Operatoren überprüfen Sie, ob die Variable durch den aktuellen Operatoraufruf mittels einer Bedingung festgelegt wurde.

Beispiel:

if ('<version>1.0.0</version>' -match '<version>(.*?)</version>') {
    $Matches
}

Ausführliche Informationen finden Sie unter about_Regular_Expressions und about_Automatic_Variables.

Ersetzungsoperator

Ersetzung mit regulären Ausdrücken

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

Syntax:

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

Der Operator ersetzt alle oder einen Teil eines Werts durch den angegebenen Wert mithilfe regulärer Ausdrücke. Sie können den Operator für viele administrative Aufgaben wie das Umbenennen von Dateien verwenden. Mit dem folgenden Befehl werden beispielsweise die Dateinamenerweiterungen aller .txt Dateien in .loggeändert:

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

Standardmäßig wird beim -replace-Operator die Groß-/Kleinschreibung nicht beachtet. Verwenden Sie -creplace, wenn die Groß-/Kleinschreibung beachtet werden soll. Verwenden Sie -ireplace, wenn die Groß-/Kleinschreibung explizit nicht beachtet werden soll.

Beispiele:

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

Cook
book

Wenn der linke Operand in einer -replace-Operatoranweisung keine Zeichenfolge ist, wird dieser Operand ab PowerShell 7.2. in eine Zeichenfolge konvertiert. PowerShell führt eine kulturunabhängige Zeichenfolgenkonvertierung durch.

Wenn Ihre Kultur beispielsweise auf „Französisch (fr)“ festgelegt ist, wird der Wert 1.2 bei der kulturabhängigen Zeichenfolgenkonvertierung zu 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 mithilfe des Dollarzeichens ($) 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

Zum Beispiel:

$1 = 'Goodbye'

'Hello World' -replace '(\w+) \w+', "$1 Universe"
# Output: Goodbye Universe

'Hello World' -replace '(\w+) \w+', '$1 Universe'
# Output: Hello Universe

$$ steht in regulären Ausdrücken tatsächlich für $. Das $$-Element in der Ersetzungszeichenfolge gibt an, dass die resultierende Ersetzung tatsächlich $ enthält. Zum 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 es sich bei der Eingabe (<input>) für den -replace-Operator um eine Auflistung handelt, wendet PowerShell die Ersetzung auf jeden Wert in der Auflistung an. Zum Beispiel:

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

Ersetzen durch einen Scriptblock

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

Syntax:

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

Verwenden Sie im Scriptblock 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 entsprechenden Zeichen ersetzt. Der Scriptblock wird für jede Reihe von drei Ziffern ausgeführt, die ersetzt werden müssen.

'072101108108111' -replace '\d{3}', {return [char][int]$_.Value}

Hello

Eindämmungsoperatoren

Die Eindämmungsoperatoren (-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 Vergleichsoperatoren 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 Ergebnisse schneller als die Gleichheitsoperatoren zurück.

-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 Operand auf der rechten Seite eine Auflistung ist, konvertieren diese Operatoren den Wert in die entsprechende Zeichenfolgendarstellung, bevor er mit der Auflistung auf der linken Seite 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 Operatoren -in und -notin wurden in PowerShell 3 als syntaktisches Gegenteil der Operatoren -contains und -notcontains eingeführt. -in gibt True zurück, wenn <scalar-object> auf der linken Seite mit einem der Elemente in der Auflistung übereinstimmt. -notin gibt stattdessen False zurück.

Die folgenden Beispiele tun dasselbe wie die Beispiele für -contains und -notcontains, 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

Wenn der Operand auf der linken Seite eine Auflistung ist, konvertieren diese Operatoren den Wert in die entsprechende Zeichenfolgendarstellung, bevor er mit der Auflistung auf der rechten Seite 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

Siehe auch

• about_Booleans
• about_Operators
• about_Regular_Expressions
• about_Wildcards
• Compare-Objekt
• ForEach-Objekt
• Where-Objekt