about_Comparison_Operators

  • Článek

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:

Rovnosti

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

Náhradní

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

Uzavření

  • -contains, – -icontains-ccontains kolekce obsahuje hodnotu.
  • -notcontains, -inotcontains– -cnotcontains kolekce neobsahuje hodnotu
  • -in – hodnota je v kolekci.
  • -notin – 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. Chcete-li operátor porovnání rozlišovat malá a velká písmena, přidejte za c .- Jedná se například -ceq o verzi -eqs rozlišováním velkých a malých písmen . Pokud chcete, aby byla rozlišování velkých a malých písmen explicitní, přidejte za i-. Například -ieq explicitně nerozlišuje velká a malá písmena verze -eq.

Porovnání řetězců používají invariantCulture pro porovnání nerozlišující malá a velká písmena. Porovnání jsou mezi body kódu Unicode a nepoužívají řazení kolace specifické pro jazykovou verzi. Výsledky jsou stejné bez ohledu na aktuální jazykovou verzi.

Pokud je vstupem operátoru skalární hodnota, vrátí operátor logickou hodnotu. Když je vstup kolekcí, vrátí operátor prvky kolekce, které odpovídají pravé hodnotě výrazu. Pokud v kolekci nejsou žádné shody, vrátí operátory porovnání prázdné pole. Pří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 vrací logickou hodnotu.
  • Operátor -replace vrátí náhradní výsledek.
  • Operátory -match také -notmatch naplní automatickou $Matches proměnnou, pokud levá strana výrazu není kolekce.

Operátory rovnosti

-eq a -ne

Pokud je skalární levá strana, vrátí hodnotu True, -eq pokud je pravá strana ekvivalentní, v opačném případě -eq vrátí hodnotu False. -ne dělá opak; vrátí hodnotu False , pokud jsou obě strany ekvivalentní. V opačném případě -ne vrátí hodnotu 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í, vrátí ty členy, -eq které odpovídají pravé straně, zatímco -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, který se má porovnat 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 nepravda , protože se jedná o různé objekty. Pokud chcete vytvořit srovnatelné třídy, musíte do třídy implementovat System.IEquatable<T> . Následující příklad ukazuje částečnou implementaci MyFileInfoSet třídy, která implementuje System.IEquatable<T> a má dvě vlastnosti, File a Size. Metoda Equals() vrátí True pokud File a Size vlastnosti dva MyFileInfoSet objekty jsou 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 $nullproměnná , musíte umístit $null na levou stranu operátoru rovnosti. Když ho umístíte na pravou stranu, nedělá to, co očekáváte.

Dejme $a tomu pole obsahující prvky null:

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

Následující testy, které $a nemají hodnotu null.

$null -ne $a

True

Následující elementy však filer out all null elements from $a:

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

1
2
4
6

-gt; -ge, -lt, and -le

-gt, , -ge-lta -le chovat se velmi podobně. Pokud jsou obě strany skalární, vrátí hodnotu True nebo False v závislosti na tom, 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 hodnotu 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íchjazykůch > V PowerShellu se tento znak používá k přesměrování. Podrobnosti najdete v tématu 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 tyto symboly operátorovi -gt , aby je porovnával 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á elementy, 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 (Regex).

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 vrátí -notmatch všechny odpovídající a neodpovídající členy. Operátory -like ale -notlike vrátí členy jako řetězce. Řetězec vrácený pro člen kolekce -like a -notlike je řetězec, který se používá pro porovnání a je získán přetypováním členu na řetězec.

-like a -notlike

-likea chovají se podobně -eq jako a -ne-notlike , ale pravá strana 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

-match a -notmatch

-match a -notmatch pomocí regulárních výrazů vyhledejte vzor 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í, vrátí operátory odpovídající č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 pro zachytávání regulárních výrazů. Pokaždé, když se spustí na skalárním vstupu a -match výsledek je True nebo -notmatch je výsledek Nepravda, přepíše automatickou $Matches proměnnou. $Matchesje hashovatelná tabulka, která má vždy klíč s názvem 0, který ukládá celou shodu. Pokud regulární výraz obsahuje skupiny zachycení, $Matches obsahuje další klíče pro každou skupinu.

Je důležité si uvědomit, že $Matches hashovatelná tabulka 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

-match Pokud je výsledek nepravda nebo -notmatch je výsledek True nebo když je vstup kolekcí, $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í po vyvolání $Matches 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 tématu about_Regular_Expressions a about_Automatic_Variables.

Operátor nahrazení

Nahrazení regulárními výrazy

-replace Operátor podobně jako -matchoperátor používá regulární výrazy k vyhledání zadaného vzoru. Ale na rozdíl od -match, nahradí shody jinou zadanou hodnotou.

Syntaxe:

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

Operátor nahradí všechny hodnoty nebo jeho část zadanou hodnotu 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í -replace je operátor 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 -replace příkazu operátoru není řetězec, tento operand se převede na řetězec. PowerShell nerozlišuje převod řetězců bez jazykové verze.

Pokud je například vaše jazyková verze nastavena na francouzštinu (fr), převod řetězce citlivého na jazykovou verzi je 1,2hodnota 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 odkazovat v řetězci <substitute> pomocí znaku dolaru ($) před identifikátorem skupiny.

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

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

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

John.Doe@Contoso.local

Upozorňující

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ď vložit regulární výrazy mezi jednoduché uvozovky, nebo před ně vložit znak zpětného znaménka (`).

Pří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 $. To $$ v náhradním řetězci pro zahrnutí literálu $ do výsledného nahrazení. Pří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

<input>-replace Pokud je operátorem kolekce, Použije PowerShell náhradu pro každou hodnotu v kolekci. Pří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í. Blok skriptu se spustí jednou pro každou shodu.

Syntaxe:

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

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

Následující příklad nahradí každou sekvenci tří číslic ekvivalenty znaků. Blok skriptu 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ž vstup je 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.

-contains and -notcontains

Syntaxe:

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

Tyto operátory říkají, zda sada obsahuje určitý prvek. -contains vrátí hodnotu True , pokud pravá strana (skalární objekt) odpovídá jednomu z prvků v sadě. -notcontains 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

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

$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 operátory byly zavedeny v PowerShellu 3 jako syntaktický opak operátorů -contains a -notcontains operátorů. -in vrátí hodnotu True , pokud levá strana <scalar-object> odpovídá jednomu z prvků v kolekci. -notin vrátí hodnotu False .

Následující příklady dělají totéž, co příklady pro -contains a -notcontains dělají, ale jsou napsané s -in a -notin místo toho.

"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é