Informacje_o_operatorach_porównania

Krótki opis

Operatory porównania w programie PowerShell mogą porównywać dwie wartości lub filtrować elementy kolekcji względem wartości wejściowej.

Długi opis

Operatory porównania umożliwiają porównywanie wartości lub znajdowanie wartości pasujących do określonych wzorców. Program PowerShell zawiera następujące operatory porównania:

Równość

-eq, -ieq, -ceq — równa się
-ne, -ine, -cne — nie równa się
-gt, -igt, -cgt — większe niż
-ge, -ige, -cge — większe lub równe
, , < mniejsze niż
-le, -ile, -cle — mniejsze lub równe

dopasowywanie

-like, -ilike, -clike, ciąg pasuje do wzorca z wieloznacznikami
-notlike, -inotlike, -cnotlike — ciąg nie pasuje do wzorca z symbolami wieloznacznymi
-match, -imatch, -cmatch — ciąg pasuje do wzorca wyrażenia regularnego
-notmatch, -inotmatch, -cnotmatch — ciąg nie jest zgodny ze wzorcem wyrażeń regularnych

zastępcze

-replace, -ireplace-creplace — znajduje i zastępuje ciągi pasujące do wzorca wyrażenia regularnego

kontrola

-contains, -icontains, -ccontains — kolekcja zawiera wartość
-notcontains, -inotcontains, -cnotcontains — kolekcja nie zawiera wartości
-in, -iin, -cin — wartość znajduje się w kolekcji
-notin, -inotin, -cnotin — wartość nie znajduje się w kolekcji

typu

-is — oba obiekty są tego samego typu
-isnot — obiekty nie są tego samego typu

Typowe funkcje

Porównania ciągów znaków są niewrażliwe na wielkość liter, chyba że używasz jawnego operatora uwzględniającego wielkość liter. Aby uczynić operator porównania wrażliwym na wielkość liter, dodaj c po -. Na przykład -ceq jest wrażliwą na wielkość liter wersją -eq. Aby wyraźnie zaznaczyć ignorowanie wielkości liter, dodaj i po -. Na przykład -ieq jest wersją -eq, która nie rozróżnia wielkości liter.

Porównania ciągów używają InvariantCulture zarówno do porównań uwzględniających wielkość liter, jak i tych, które jej nie uwzględniają. Porównania są między punktami kodu Unicode i nie używają kolejności sortowania specyficznego dla kultury. Wyniki są takie same niezależnie od bieżącej kultury.

Gdy wartość po lewej stronie w wyrażeniu porównania jest wartością skalarną, operator zwraca wartość logiczną . Gdy wartość po lewej stronie w wyrażeniu jest kolekcją, operator zwraca elementy kolekcji zgodne z prawą wartością wyrażenia. Wartości po prawej stronie są zawsze traktowane jako pojedyncze instancje, nawet jeśli są kolekcjami. Operatory porównania nie mogą skutecznie porównywać kolekcji z kolekcjami.

Jeśli w kolekcji nie ma dopasowań, operatory porównania zwracają pustą tablicę. Na przykład:

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

Object[]
0

Istnieje kilka wyjątków:

Operatory zawierania i typu zawsze zwracają wartość logiczną
Operator -replace zwraca wynik zastąpienia
Operatory -match i -notmatch również wypełniają zmienną automatyczną $Matches, chyba że lewa strona wyrażenia jest kolekcją.

Operatory równości

-eq i -ne

Gdy lewa strona jest skalarna, -eq zwraca wartość true, jeśli prawa strona jest równoważna, w przeciwnym razie -eq zwraca wartość False. -ne robi odwrotnie; zwraca False, gdy obie strony są równoważne; w przeciwnym razie -ne zwraca True.

Przykład:

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

Gdy lewa strona jest kolekcją, -eq zwraca te elementy, które pasują do prawej strony, a -ne odfiltrowuje je.

Przykład:

1,2,3 -eq 2             # Output: 2
'abc', 'def' -eq 'abc'  # Output: abc
'abc', 'def' -ne 'abc'  # Output: def

Te operatory przetwarzają wszystkie elementy kolekcji. Przykład:

'zzz', 'def', 'zzz' -eq 'zzz'

zzz
zzz

Operator równości może porównywać obiekty różnych typów. Ważne jest, aby zrozumieć, że wartość po prawej stronie porównania można przekonwertować na typ wartości po lewej stronie do porównania.

Na przykład ciąg '1.0' jest konwertowany na liczbę całkowitą, która ma być porównywana z wartością 1. Ten przykład zwraca True.

PS> 1 -eq '1.0'
True

W tym przykładzie wartość 1 jest konwertowana na ciąg do porównania z ciągiem '1.0'. Ten przykład zwraca False.

PS> '1.0' -eq 1
False

Operatory równości akceptują dowolne dwa obiekty, nie tylko skalary lub kolekcje. Jednak wynik porównania nie jest gwarantowany jako znaczący dla użytkownika końcowego. W poniższym przykładzie pokazano 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

W tym przykładzie utworzyliśmy dwa obiekty o identycznych właściwościach. Jednak wynik testu równości jest false, ponieważ są to różne obiekty. Aby utworzyć porównywalne klasy, należy zaimplementować System.IEquatable<T> w klasie. W poniższym przykładzie pokazano częściową implementację klasy MyFileInfoSet, która implementuje System.IEquatable<T> i ma dwie właściwości, File i Size. Metoda Equals() zwraca True, jeśli właściwości Plik i Rozmiar dwóch obiektów MyFileInfoSet są takie same.

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

Wybitnym przykładem porównywania dowolnych obiektów jest stwierdzenie, czy mają wartość null. Jeśli jednak musisz określić, czy zmienna jest $null, należy umieścić $null po lewej stronie operatora równości. Umieszczenie go po prawej stronie nie robi tego, czego oczekujesz.

Załóżmy na przykład, że $a jest tablicą zawierającą puste elementy.

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

Następujące testy sprawdzają, czy $a nie jest wartością null.

$null -ne $a

True

Następująca instrukcja jednak filtrować wszystkie elementy null z $a:

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

-gt, -ge, -lt i -le

-gt, -ge, -lti -le zachowują się bardzo podobnie. Gdy obie strony są skalarne, zwracają true lub false w zależności od tego, jak obie strony porównują:

Obsługujący	Zwraca wartość True, gdy...
`-gt`	Lewa strona jest większa
`-ge`	Lewa strona jest większa lub równa
`-lt`	Lewa strona jest mniejsza
`-le`	Lewa strona jest mniejsza lub równa

W poniższych przykładach wszystkie instrukcje zwracają true.

8 -gt 6  # Output: True
8 -ge 8  # Output: True
6 -lt 8  # Output: True
8 -le 8  # Output: True

Notatka

W większości języków programowania operator większy niż jest >. W programie PowerShell ten znak jest używany do przekierowywania. Aby uzyskać szczegółowe informacje, zobacz about_Redirection.

Gdy lewa strona jest kolekcją, te operatory porównują każdy element kolekcji z elementami po prawej stronie. W zależności od ich logiki zachowują lub odrzucają członka.

Przykład:

$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

Te operatory współpracują z dowolną klasą, która implementuje System.IComparable.

Przykłady:

# 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'

W poniższym przykładzie pokazano, że nie ma symbolu na amerykańskiej klawiaturze QWERTY, która jest sortowana po znaku "a". Przekazuje zestaw zawierający wszystkie takie symbole do operatora -gt, aby porównać je z "a". Wynik to pusta tablica.

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

Jeśli obie strony operatorów nie są wystarczająco porównywalne, te operatory zgłaszają błąd bez zakończenia.

Pasujące operatory

Pasujące operatory (-like, -notlike, -matchi -notmatch) znajdują elementy zgodne lub nie pasują do określonego wzorca. Wzorzec dla -like elementu i -notlike jest wyrażeniem wieloznacznymi (zawierającym *, ?i [ ]), podczas gdy -match i -notmatch akceptuje wyrażenie regularne (regex).

Składnia to:

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

Gdy dane wejściowe tych operatorów są wartością skalarną, zwracają wartość logiczną.

Gdy dane wejściowe są kolekcją wartości, każdy element w kolekcji jest konwertowany na ciąg do porównania. Operatory -match i -notmatch zwracają odpowiednio wszystkie pasujące i niezgodne elementy członkowskie. Jednak operatory -like i -notlike zwracają elementy członkowskie jako ciągi. Ciąg zwracany dla elementu członkowskiego kolekcji przez -like i -notlike jest ciągiem, który operator używany do porównania i jest uzyskiwany przez rzutowanie elementu członkowskiego do ciągu.

-podobny i -notlike

-like i -notlike zachowują się podobnie do -eq i -ne, ale po prawej stronie może być ciąg zawierający symbole wieloznaczne .

Przykład:

'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

Aby uzyskać najlepsze wyniki, prawa strona operatorów -like i -notlike powinna być literałem ciągu zawierającym wyrażenie wieloznaczne. Program PowerShell przekazuje wyrażenie wieloznaczne do analizatora wyrażeń wieloznacznych. Aby dopasować jeden z symboli wieloznacznych (*, , lub ?), należy go uruchomić za pomocą znaku backtick ([ ]`). Na przykład, aby dopasować literał ?, użyj w `? wyrażeniu wieloznacznymi. Jeśli używasz rozszerzalnego wyrażenia ciągu, program PowerShell rozszerza ciąg przed przekazaniem go do analizatora symboli wieloznacznych, co powoduje wysyłanie niezasłanych znaków jako symboli wieloznacznych.

# 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

-mecz i -notmatch

-match i -notmatch używają wyrażeń regularnych do wyszukiwania wzorca w wartościach po lewej stronie. Wyrażenia regularne mogą być zgodne ze złożonymi wzorcami, takimi jak adresy e-mail, ścieżki UNC lub sformatowane numery telefonów. Ciąg po prawej stronie musi być zgodny z zasadami wyrażeń regularnych .

Przykłady skalarne:

# 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

Jeśli wejście jest kolekcją, operatorzy zwracają pasujące elementy tej kolekcji.

Przykłady kolekcji:

'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 i -notmatch obsługują grupy przechwytywania wyrażeń regularnych. Za każdym razem, gdy są uruchamiane na skalarnych danych wejściowych i wynikiem -match jest True, lub wynikiem -notmatch jest False, nadpisują $Matches zmienną automatyczną. $Matches to tablica mieszająca, która zawsze ma klucz o nazwie "0", przechowujący całe dopasowanie. Jeśli wyrażenie regularne zawiera grupy przechwytywania, to $Matches zawiera dodatkowe klucze dla każdej z tych grup.

Należy pamiętać, że tabela skrótów $Matches zawiera tylko pierwsze wystąpienie dowolnego pasującego wzorca.

Przykład:

$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

Gdy wynikiem -match jest falselub wynik -notmatch jest truelub gdy dane wejściowe są kolekcją, zmienna automatyczna $Matches nie jest zastępowana. W związku z tym będzie zawierać wcześniej ustawioną wartość lub $null, jeśli zmienna nie została ustawiona. Podczas odwoływania się do $Matches po wywołaniu jednego z tych operatorów, rozważ sprawdzenie za pomocą instrukcji warunkowej, czy zmienna została ustawiona przez bieżące wywołanie operatora.

Przykład:

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

Aby uzyskać szczegółowe informacje, zobacz about_Regular_Expressions i about_Automatic_Variables.

Operator zastępczy

Zastępowanie za pomocą wyrażeń regularnych

Podobnie jak -match, operator -replace używa wyrażeń regularnych do znalezienia określonego wzorca. Ale w przeciwieństwie do -match, zastępuje odpowiedniki inną określoną wartością.

Składnia:

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

Operator zastępuje całą lub część wartości określoną wartością przy użyciu wyrażeń regularnych. Możesz użyć operatora dla wielu zadań administracyjnych, takich jak zmiana nazwy plików. Na przykład następujące polecenie zmienia rozszerzenia nazw plików wszystkich plików .txt na .log:

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

Domyślnie operator -replace nie uwzględnia wielkości liter. Aby włączyć uwzględnianie wielkości liter, użyj -creplace. Aby jawnie nie uwzględniać wielkości liter, użyj -ireplace.

Przykłady:

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

Cook
book

Począwszy od programu PowerShell 7.2, gdy operand po lewej stronie w instrukcji operatora -replace nie jest ciągiem, operand jest konwertowany na ciąg. Program PowerShell wykonuje konwersję ciągów bez uwzględniania kultury.

Na przykład, jeśli ustawisz kulturę na francuski (fr), wartość 1.2 zostanie przekształcona na 1,2zgodnie z zasadami lokalnej konwersji znaków.

Przed programem PowerShell 7.2:

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

W programie PowerShell 7.2 lub nowszym:

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

Podstawienia wyrażeń regularnych

Można również używać wyrażeń regularnych do dynamicznej zamiany tekstu, wykorzystując grupy przechwytujące i substytucje. Do grup przechwytywania można odwoływać się w ciągu <substitute> przy użyciu znaku dolara ($) przed identyfikatorem grupy.

W poniższym przykładzie operator -replace akceptuje nazwę użytkownika w postaci DomainName\Username i konwertuje na format Username@DomainName:

$SearchExp = '^(?<DomainName>[\w-.]+)\\(?<Username>[\w-.]+)$'
$ReplaceExp = '${Username}@${DomainName}'

'Contoso.local\John.Doe' -replace $SearchExp, $ReplaceExp

John.Doe@Contoso.local

Ostrzeżenie

Znak $ ma role składniowe zarówno w programie PowerShell, jak i wyrażeniach regularnych:

W programie PowerShell między podwójnym cudzysłowem wyznacza zmienne i działa jako operator podexpressionu.
W wyszukiwaniach za pomocą wyrażeń regularnych oznacza koniec linii.
W ciągach podstawienia wyrażeń regularnych (Regex) oznacza wyłapane grupy. Pamiętaj, aby umieścić wyrażenia regularne między pojedynczymi apostrofami lub wstawić znak tyldy (`) przed nimi.

Na przykład:

$1 = 'Goodbye'

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

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

$$ w wyrażeniu regularnym oznacza literał $. Aby uwzględnić literał $$ w wynikowej zamianie, użyj $ w ciągu podstawienia. Na przykład:

'5.72' -replace '(.+)', '$ $1' # Output: $ 5.72
'5.72' -replace '(.+)', '$$$1' # Output: $5.72
'5.72' -replace '(.+)', '$$1'  # Output: $1

Aby dowiedzieć się więcej, zobacz about_Regular_Expressions i Substitutions in Regular Expressions.

Podstawianie w kolekcji

Gdy operator <input> do -replace jest kolekcją, program PowerShell stosuje zastąpienie każdej wartości w kolekcji. Na przykład:

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

Zastępowanie za pomocą blokady skryptu

W programie PowerShell 6 lub nowszym -replace operator akceptuje również blok skryptu, który wykonuje zamianę. Blok skryptów jest uruchamiany raz dla każdego dopasowania.

Składnia:

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

W bloku skryptu użyj zmiennej automatycznej $_ , aby uzyskać dostęp do zastępowanego tekstu wejściowego i innych przydatnych informacji. Typ klasy tej zmiennej to System.Text.RegularExpressions.Match.

Poniższy przykład zastępuje każdą sekwencję trzech cyfr odpowiednikami znaków. Blok skryptów jest uruchamiany dla każdego zestawu trzech cyfr, które należy zamienić.

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

Hello

Operatory zawierania

Operatory zawierania (-contains, -notcontains, -ini -notin) są podobne do operatorów równości, z tą różnicą, że zawsze zwracają wartość logiczną , nawet jeśli dane wejściowe są kolekcją. Te operatory przestają porównywać natychmiast po wykryciu pierwszego dopasowania, podczas gdy operatory równości oceniają wszystkie składowe danych wejściowych. W bardzo dużej kolekcji te operatory działają szybciej niż operatory równości.

-zawiera i -notcontains

Składnia:

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

Te operatory informują, czy zestaw zawiera określony element. -contains zwraca wartość True, gdy prawa strona (obiekt skalarny) pasuje do jednego z elementów w zbiorze. -notcontains zamiast tego zwraca wartość False.

Przykłady:

'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

Bardziej złożone przykłady:

$DomainServers = 'ContosoDC1', 'ContosoDC2', 'ContosoFileServer',
                 'ContosoDNS', 'ContosoDHCP', 'ContosoWSUS'
$thisComputer  = 'ContosoDC2'

$DomainServers -contains $thisComputer
# Output: True

Gdy operand po prawej stronie jest kolekcją, te operatory konwertują wartość na reprezentację ciągu przed porównaniem jej z kolekcją po lewej stronie.

$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 i -notin

Składnia:

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

Operatory -in i -notin zostały wprowadzone w programie PowerShell 3 jako składniowe przeciwieństwo operatorów -contains i -notcontains. -in zwraca True, gdy lewa strona <scalar-object> pasuje do jednego z elementów w kolekcji. -notin zamiast tego zwraca false.

Poniższe przykłady robią to samo, co w przykładach -contains i -notcontains, ale są one napisane przy użyciu -in i -notin zamiast tego.

'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

Bardziej złożone przykłady:

$DomainServers = 'ContosoDC1', 'ContosoDC2', 'ContosoFileServer',
                 'ContosoDNS', 'ContosoDHCP', 'ContosoWSUS'
$thisComputer  = 'ContosoDC2'

$thisComputer -in $DomainServers
# Output: True

Gdy operand po lewej stronie jest kolekcją, te operatory konwertują wartość na reprezentację ciągu przed porównaniem jej z kolekcją po prawej stronie.

$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

Porównanie typów

Operatory porównania typów (-is i -isnot) służą do określania, czy obiekt jest określonym typem.

Składnia:

<object> -is <type-reference>
<object> -isnot <type-reference>

Przykład:

$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

Zobacz także

Opinia

Czy ta strona była pomocna?

Last updated on 2026-01-18

Udostępnij za pośrednictwem

Informacje_o_operatorach_porównania

Krótki opis

Długi opis

Typowe funkcje

Operatory równości

-eq i -ne

-gt, -ge, -lt i -le

Pasujące operatory

-podobny i -notlike

-mecz i -notmatch

Operator zastępczy

Zastępowanie za pomocą wyrażeń regularnych

Podstawienia wyrażeń regularnych

Podstawianie w kolekcji

Zastępowanie za pomocą blokady skryptu

Operatory zawierania

-zawiera i -notcontains

-in i -notin

Porównanie typów

Zobacz także

Opinia

Dodatkowe zasoby