informace_o_poručovacích_operátorech

Krátký popis

Operátory porovnání v PowerShellu můžou buď porovnat dvě hodnoty, nebo filtrovat prvky kolekce se vstupní hodnotou.

Dlouhý popis

Operátory porovnání umožňují porovnat hodnoty nebo najít hodnoty, které odpovídají zadaným vzorům. PowerShell obsahuje následující relační operátory:

rovnost

-eq, -ieq, -ceq – rovná se
-ne, -ine, -cne – nerovná se
-gt, -igt, -cgt - větší než
-ge, -ige, -cge – větší nebo rovno
-lt, -ilt, -clt - menší než
-le, -ile, -cle – menší nebo rovno

odpovídající

-like, -ilike, -clike – řetězec odpovídá vzoru se zástupnými znaky
-notlike, -inotlike, -cnotlike – řetězec neodpovídá vzoru se zástupnými znaky
-match, -imatch, -cmatch – řetězec odpovídá vzoru regulárního výrazu
-notmatch, -inotmatch, -cnotmatch – řetězec neodpovídá vzoru regulárního výrazu

nahrazení

-replace, – -ireplace-creplace najde a nahradí řetězce odpovídající vzoru regulárního výrazu.

Zadržování

-contains, -icontains, -ccontains – kolekce obsahuje hodnotu
-notcontains, -inotcontains, -cnotcontains – kolekce neobsahuje žádnou hodnotu
-in, -iin, -cin – hodnota se nachází v kolekci
-notin, -inotin, -cnotin – hodnota není v kolekci

typ

-is – oba objekty jsou stejného typu
-isnot – objekty nejsou stejného typu

Běžné funkce

Porovnání řetězců nerozlišují malá a velká písmena, pokud nepoužíváte explicitní operátor rozlišující velká a malá písmena. Operátor porovnání bude rozlišovat malá a velká písmena, pokud přidáte c za -. Například -ceq je verze -eqs rozlišováním malých a velkých písmen . Chcete-li nerozlišovat malá a velká písmena explicitně, přidejte i za -. Například -ieq je explicitní verze -eqnerozlišující velká a malá písmena .

Porovnávání řetězců používá InvariantCulture pro rozlišovací i nerozlišovací porovnání malých a velkých písmen. Porovnání jsou mezi kódovými body Unicode a nepoužívají řazení podle kulturního pořadí. Výsledky jsou stejné bez ohledu na aktuální kulturu.

Pokud je levou hodnotou ve výrazu porovnání skalární hodnota, vrátí operátor logickou hodnotu. Pokud je hodnota vlevo ve výrazu kolekce, vrátí operátor prvky kolekce, které odpovídají pravé hodnotě výrazu. Hodnoty na pravé straně jsou vždy považovány za singletonové instance, i když jsou to kolekce. Operátory porovnání nemůžou efektivně porovnávat kolekce s kolekcemi.

Pokud v kolekci nejsou žádné shody, vrátí operátory porovnání prázdné pole. Například:

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

Object[]
0

Existuje několik výjimek:

Operátory zahrnutí a typu vždy vracejí logickou hodnotu.
Operátor -replace vrátí náhradní výsledek.
Operátory -match a -notmatch také naplní $Matches automatickou proměnnou, pokud levá strana výrazu není kolekce.

Operátory rovnosti

-eq a -ne

Pokud je levá strana skalární, -eq vrátí True pokud je pravá strana ekvivalentní, v opačném případě -eq vrátí False. -ne dělá opak; vrátí False, pokud jsou obě strany ekvivalentní; v opačném případě -ne vrátí true.

Příklad:

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

Když je levá strana kolekcí, -eq vrátí členy, které odpovídají pravé straně, a -ne je vyfiltruje.

Příklad:

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

Tyto operátory zpracovávají všechny prvky kolekce. Příklad:

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

zzz
zzz

Operátor rovnosti může porovnávat objekty různých typů. Je důležité si uvědomit, že hodnota na pravé straně porovnání se dá převést na typ hodnoty na levé straně pro porovnání.

Například řetězec '1.0' je převeden na celé číslo, které se má porovnat s hodnotou 1. Tento příklad vrátí True.

PS> 1 -eq '1.0'
True

V tomto příkladu je hodnota 1 převedena na řetězec, aby mohla být porovnána s řetězcem '1.0'. Tento příklad vrátí False.

PS> '1.0' -eq 1
False

Operátory rovnosti přijímají všechny dva objekty, nejen skalární nebo kolekci. Výsledek porovnání ale není zaručen, že bude pro koncového uživatele smysluplný. Následující příklad ukazuje problém.

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

V tomto příkladu jsme vytvořili dva objekty s identickými vlastnostmi. Výsledek testu rovnosti je ale false, protože se jedná o různé objekty. Pokud chcete vytvořit srovnatelné třídy, musíte ve třídě implementovat System.IEquatable<T>. Následující příklad ukazuje částečnou implementaci třídy MyFileInfoSet, která implementuje System.IEquatable<T> a má dvě vlastnosti, File a Size. Metoda Equals() vrátí True, pokud jsou vlastnosti File a Size dvou MyFileInfoSet objektů stejné.

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

Významným příkladem porovnání libovolných objektů je zjištění, jestli mají hodnotu null. Pokud ale potřebujete určit, jestli je proměnná $null, musíte $null umístit na levou stranu operátoru rovnosti. Když ho umístíte na pravou stranu, nedělá to, co očekáváte.

Například nechť $a je pole obsahující nulové prvky:

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

Následující test kontroluje, že $a není null.

$null -ne $a

True

Následující však filtruje všechny nulové prvky z $a:

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

-gt, -ge, -lt a -le

-gt, -ge, -lta -le se chovají velmi podobně. Pokud jsou obě strany skalární, vrátí true nebo false podle toho, jak obě strany porovnávají:

Operátor	Vrátí hodnotu True, když...
`-gt`	Levá strana je větší
`-ge`	Levá strana je větší nebo rovna
`-lt`	Levá strana je menší.
`-le`	Levá strana je menší nebo rovna

V následujících příkladech vrátí všechny příkazy True.

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

Poznámka

Ve většině programovacích jazyků je operátor větší než >. V PowerShellu se tento znak používá k přesměrování. Podrobnosti najdete v části about_Redirection.

Pokud je levá strana kolekcí, tyto operátory porovnávají jednotlivé členy kolekce s pravou stranou. V závislosti na jejich logice buď člena zachovají, nebo zahodí.

Příklad:

$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

Tyto operátory pracují s libovolnou třídou, která implementuje System.IComparable.

Příklady:

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

Následující příklad ukazuje, že na americké klávesnici QWERTY není žádný symbol, který se seřadí za "a". Podává sadu obsahující všechny takové symboly operátoru -gt, aby je porovnal s 'a'. Výstup je prázdné pole.

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

Pokud obě strany operátorů nejsou přiměřeně srovnatelné, tyto operátory vyvolávají neukončující chybu.

Odpovídající operátory

Odpovídající operátory (-like, -notlike, -matcha -notmatch) vyhledá prvky, které odpovídají zadanému vzoru nebo neodpovídají zadanému vzoru. Vzor pro -like výraz -notlike se zástupným znakem (obsahující *znak , ?a [ ]) zatímco -match a -notmatch přijímá regulární výraz (regulární výraz).

Syntaxe je:

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

Pokud je vstupem těchto operátorů skalární hodnota, vrátí logickou hodnotu.

Když je vstup kolekcí hodnot, každá položka v kolekci se převede na řetězec pro porovnání. Operátory -match a -notmatch vrátí všechny odpovídající a neodpovídající členy. Operátory -like a -notlike však vrátí členy jako řetězce. Řetězec vrácený pro členy kolekce označené jako -like a -notlike je ten, který operátor použil pro porovnání a je získán přetypováním člena na řetězec.

-podobný a -notlike

-like a -notlike se chovají podobně jako -eq a -ne, ale na pravé straně může být řetězec obsahující zástupné znaky.

Příklad:

'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

Nejlepších výsledků dosáhnete tak, že pravá strana operátoru -like a -notlike operátory bude řetězcový literál obsahující výraz se zástupnými znaky. PowerShell předá výraz se zástupným znakem analyzátoru zástupných znaků. Chcete-li spárovat jeden ze zástupných znaků (*, ?nebo [ ]), musíte u něj utéct znakem zpětného znaku (`). Pokud chcete například shodovat literál ?, použijte `? ve výrazu se zástupným znakem. Pokud použijete rozbalitelný řetězcový výraz, PowerShell před jeho předáním do analyzátoru zástupných znaků rozbalí řetězec, což vede k tomu, že se neposílané znaky odesílají jako zástupné znaky.

# 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 a -notmatch

-match a -notmatch používají regulární výrazy k vyhledání vzoru v hodnotách na levé straně. Regulární výrazy můžou odpovídat složitým vzorům, jako jsou e-mailové adresy, cesty UNC nebo formátovaná telefonní čísla. Řetězec na pravé straně musí dodržovat pravidla regulárních výrazů .

Skalární příklady:

# 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

Pokud je vstup kolekcí, operátory vrátí shodující se členy této kolekce.

Příklady kolekcí:

'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 a -notmatch podporují skupiny zachycení regulárních výrazů. Pokaždé, když se spustí skalární vstup a -match výsledek je truenebo -notmatch výsledek je False, přepíše $Matches automatické proměnné. $Matches je tabulka hodnot, která má vždy klíč s názvem '0', který ukládá celou shodu. Pokud regulární výraz obsahuje zachytávací skupiny, $Matches obsahuje další klíče pro každou skupinu.

Je důležité si uvědomit, že $Matches hashtable obsahuje pouze první výskyt jakéhokoli odpovídajícího vzoru.

Příklad:

$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

Pokud je výsledek -matchFalsenebo je výsledek -notmatchTrue, nebo když je vstup kolekce, $Matches automatická proměnná se nepřepíše. V důsledku toho bude obsahovat dříve nastavenou hodnotu nebo $null, pokud proměnná nebyla nastavena. Při odkazování na $Matches po vyvolání jednoho z těchto operátorů zvažte ověření, že proměnná byla nastavena voláním aktuálního operátoru pomocí příkazu podmínky.

Příklad:

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

Podrobnosti najdete v části () about_Regular_Expressions () a () about_Automatic_Variables ().

Operátor nahrazení

Nahrazení regulárními výrazy

Podobně jako -matchpoužívá operátor -replace k vyhledání zadaného vzoru regulární výrazy. Na rozdíl od -matchale nahradí shody jinou zadanou hodnotou.

Syntaxe:

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

Operátor nahradí všechny nebo část hodnoty zadanou hodnotou pomocí regulárních výrazů. Operátor můžete použít pro mnoho úloh správy, jako je přejmenování souborů. Například následující příkaz změní přípony názvů souborů všech .txt souborů na .log:

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

Ve výchozím nastavení je operátor -replace nerozlišující malá a velká písmena. Pokud chcete rozlišovat malá a velká písmena, použijte -creplace. Pokud chcete explicitně nerozlišovat malá a velká písmena, použijte -ireplace.

Příklady:

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

Cook
book

Počínaje PowerShellem 7.2, pokud levý operand v příkazu operátoru -replace není řetězec, tento operand se převede na řetězec. PowerShell provádí převod řetězců bez ohledu na kulturní nastavení.

Pokud je například jazyková verze nastavena na francouzštinu (fr), převod řetězce citlivého na jazykovou verzi 1.2 je 1,2.

Před PowerShellem 7.2:

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

V PowerShellu 7.2 a novějším:

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

Nahrazení regulárních výrazů

Pomocí regulárních výrazů je také možné dynamicky nahradit text pomocí zachytávání skupin a nahrazování. Skupiny zachycení lze v řetězci <substitute> odkazovat pomocí symbolu dolaru ($) před identifikátorem skupiny.

V následujícím příkladu operátor -replace přijme uživatelské jméno ve formě DomainName\Username a převede na formát Username@DomainName:

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

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

John.Doe@Contoso.local

Varování

Znak $ má syntaktické role v PowerShellu i regulárních výrazech:

V PowerShellu mezi dvojitými uvozovkami označuje proměnné a funguje jako operátor dílčího výrazu.
Ve vyhledávacích řetězcích regulárního výrazu označuje konec řádku.
V náhradních řetězcích regulárních výrazů označuje zachycené skupiny. Nezapomeňte buď umístit regulární výrazy mezi jednoduché uvozovky, nebo před ně vložit znak zpětného apostrofu (`).

Například:

$1 = 'Goodbye'

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

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

$$ v regulárním výrazu označuje literál $. Tento $$ v náhradním řetězci slouží k tomu, aby ve výsledném nahrazení byl zahrnut doslovný $. Například:

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

Další informace najdete v tématu about_Regular_Expressions a Nahrazení v regulárních výrazech.

Nahrazení v kolekci

Když je operátor <input> až -replace kolekce, PowerShell použije náhradu pro každou hodnotu v kolekci. Například:

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

Nahrazení blokem skriptu

V PowerShellu 6 a novějším -replace přijímá operátor také blok skriptu, který provede nahrazení. Skriptblock se spustí jednou pro každou shodu.

Syntaxe:

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

V rámci skriptublock použijte automatickou $_ proměnnou pro přístup ke vstupnímu textu, který se nahrazuje, a další užitečné informace. Typ třídy této proměnné je System.Text.RegularExpressions.Match.

Následující příklad nahradí každou sekvenci tří číslic ekvivalenty znaků. Skriptblock se spustí pro každou sadu tří číslic, které je potřeba nahradit.

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

Hello

Operátory zahrnutí

Operátory zahrnutí (-contains, -notcontains, -ina -notin) jsou podobné operátorům rovnosti, s tím rozdílem, že vždy vrací logickou hodnotu, i když je vstup kolekce. Tyto operátory přestanou porovnávat hned po zjištění první shody, zatímco operátory rovnosti vyhodnotí všechny vstupní členy. Ve velmi velké kolekci vrátí tyto operátory rychleji než operátory rovnosti.

-obsahuje a také -notcontains

Syntaxe:

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

Tyto operátory říkají, zda sada obsahuje určitý prvek. -contains vrátí true, když se pravá strana (skalární objekt) shoduje s jedním z prvků v sadě. -notcontains místo toho vrátí hodnotu False.

Příklady:

'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

Složitější příklady:

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

$DomainServers -contains $thisComputer
# Output: True

Když je operand na pravé straně kolekcí, tyto operátory převedou hodnotu na její řetězcovou reprezentaci, než ji porovnají s kolekcí na levé straně.

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

Syntaxe:

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

Operátory -in a -notin byly v PowerShellu 3 zavedeny jako syntaktický opak operátorů -contains a -notcontains. -in vrátí True, když je levá strana <scalar-object> shodná s některým z prvků v kolekci. -notin místo toho vrátí False.

Následující příklady fungují stejně jako příklady pro -contains a -notcontains, ale jsou napsané s -in a -notin.

'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

Složitější příklady:

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

$thisComputer -in $DomainServers
# Output: True

Pokud je operand na levé straně kolekcí, tyto operátory před porovnáním s kolekcí na pravé straně převedou hodnotu na řetězcovou reprezentaci.

$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

Porovnání typů

Operátory porovnání typů (-is a -isnot) slouží k určení, zda je objekt konkrétním typem.

Syntaxe:

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

Příklad:

$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

Viz také

Váš názor

Byla tato stránka užitečná?

Last updated on 2026-01-18

informace_o_poručovacích_operátorech

Krátký popis

Dlouhý popis

Běžné funkce

Operátory rovnosti

-eq a -ne

-gt, -ge, -lt a -le

Odpovídající operátory

-podobný a -notlike

-match a -notmatch

Operátor nahrazení

Nahrazení regulárními výrazy

Nahrazení regulárních výrazů

Nahrazení v kolekci

Nahrazení blokem skriptu

Operátory zahrnutí

-obsahuje a také -notcontains

-in a -notin

Porovnání typů

Viz také

Váš názor

Další materiály