about_Comparison_Operators

Artigo
05/09/2024

Descrição breve

Os operadores de comparação no PowerShell podem comparar dois valores ou filtrar elementos de uma coleção com um valor de entrada.

Descrição longa

Os operadores de comparação permitem comparar valores ou localizar valores que correspondem aos padrões especificados. O PowerShell inclui os seguintes operadores de comparação:

Igualitário

-eq, -ieq, -ceq - é igual a
-ne, -ine, -cne - não é igual a
-gt, -igt, -cgt – maior que
-ge, -ige, -cge – maior ou igual a
-lt, -ilt, -clt - menor que
-le, -ile, -cle – menor ou igual a

Correspondência

-like, -ilike, -clike – a cadeia de caracteres corresponde ao padrão curinga
-notlike, -inotlike, -cnotlike – a cadeia de caracteres não corresponde ao padrão curinga
-match, -imatch, -cmatch – a cadeia de caracteres corresponde ao padrão regex
-notmatch, -inotmatch, -cnotmatch – a cadeia de caracteres não corresponde ao padrão regex

Substituição

-replace, -ireplace, -creplace – substitui cadeias de caracteres que correspondem a um padrão regex

Contenção

-contains, -icontains, -ccontains – a coleção contém um valor
-notcontains, -inotcontains, -cnotcontains – a coleção não contém um valor
-in – o valor está em uma coleção
-notin – o valor não está em uma coleção

Tipo

-is – ambos os objetos são do mesmo tipo
-isnot – os objetos não são do mesmo tipo

Recursos comuns

As comparações de cadeia de caracteres não diferenciam maiúsculas de minúsculas, a menos que você use o operador explícito que diferencia maiúsculas de minúsculas. Para tornar um operador de comparação que diferencia maiúsculas de minúsculas, adicione um c após o -. Por exemplo, -ceq é a versão que diferencia maiúsculas de minúsculas de -eq. Para tornar a diferenciação de maiúsculas e minúsculas explícita, adicione um i após -. Por exemplo, -ieq é a versão explicitamente que não diferencia maiúsculas de minúsculas de -eq.

As comparações de cadeia de caracteres usam InvariantCulture para comparações que diferenciam maiúsculas de minúsculas e que não diferenciam maiúsculas de minúsculas. As comparações são entre pontos de código unicode e não usam ordenação de ordenação específica da cultura. Os resultados são os mesmos, independentemente da cultura atual.

Quando a entrada de um operador é um valor escalar , o operador retorna um valor booliano . Quando a entrada é uma coleção, o operador retorna os elementos da coleção que correspondem ao valor à direita da expressão. Se não houver correspondências na coleção, os operadores de comparação retornarão uma matriz vazia. Por exemplo:

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

Object[]
0

Há algumas exceções:

Os operadores de contenção e tipo sempre retornam um valor booliano
O -replace operador retorna o resultado de substituição
Os -match operadores e -notmatch também preenchem a $Matches variável automática, a menos que o lado esquerdo da expressão seja uma coleção.

Operadores de igualdade

-eq e -ne

Quando o lado esquerdo for escalar, -eq retornará True se o lado direito for equivalente, caso contrário, -eq retornará False. -ne faz o oposto; retorna False quando ambos os lados são equivalentes; caso contrário, -ne retornará True.

Exemplo:

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

Quando o lado esquerdo é uma coleção, -eq retorna os membros que correspondem ao lado direito, enquanto -ne os filtra.

Exemplo:

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

Esses operadores processam todos os elementos da coleção. Exemplo:

"zzz", "def", "zzz" -eq "zzz"

zzz
zzz

O operador de igualdade pode comparar objetos de diferentes tipos. É importante entender que o valor no lado direito da comparação pode ser convertido no tipo do valor do lado esquerdo para comparação.

Por exemplo, a cadeia de caracteres '1.0' é convertida em um inteiro a ser comparado ao valor 1. Este exemplo retorna True.

PS> 1 -eq '1.0'
True

Neste exemplo, o valor 1 é convertido em uma cadeia de caracteres a ser comparada à cadeia de caracteres '1.0'. Este exemplo retorna False.

PS> '1.0' -eq 1
False

Os operadores de igualdade aceitam dois objetos, não apenas um escalar ou uma coleção. Mas não há garantia de que o resultado da comparação seja significativo para o usuário final. O exemplo a seguir demonstra o problema.

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

Neste exemplo, criamos dois objetos com propriedades idênticas. No entanto, o resultado do teste de igualdade é False porque são objetos diferentes. Para criar classes comparáveis, você precisa implementar System.IEquatable<T> em sua classe. O exemplo a seguir demonstra a implementação parcial de uma classe MyFileInfoSet que implementa System.IEquatable<T> e tem duas propriedades, File e Size. O Equals() método retornará True se as propriedades File e Size de dois objetos MyFileInfoSet forem as mesmas.

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

Um exemplo proeminente de comparação de objetos arbitrários é descobrir se eles são nulos. Mas se você precisar determinar se uma variável é $null, deverá colocar $null no lado esquerdo do operador de igualdade. Colocá-lo no lado direito não faz o que você espera.

Por exemplo, vamos $a ser uma matriz que contém elementos nulos:

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

Os testes a seguir que $a não são nulos.

$null -ne $a

True

No entanto, o seguinte arquivar todos os elementos nulos de $a:

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

-gt, -ge, -lt e -le

-gt, -ge, -lte -le se comportam de maneira muito semelhante. Quando ambos os lados são escalares, eles retornam True ou False , dependendo de como os dois lados se comparam:

Operador	Retorna True quando...
`-gt`	O lado esquerdo é maior
`-ge`	O lado esquerdo é maior ou igual
`-lt`	O lado esquerdo é menor
`-le`	O lado esquerdo é menor ou igual

Nos exemplos a seguir, todas as instruções retornam True.

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

Observação

Na maioria das linguagens de programação, o operador maior que é >. No PowerShell, esse caractere é usado para redirecionamento. Para obter detalhes, consulte about_Redirection.

Quando o lado esquerdo é uma coleção, esses operadores comparam cada membro da coleção com o lado direito. Dependendo da lógica, eles mantêm ou descartam o membro.

Exemplo:

$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

Esses operadores funcionam com qualquer classe que implemente System.IComparable.

Exemplos:

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

O exemplo a seguir demonstra que não há nenhum símbolo em um teclado QWERTY americano que seja classificado após 'a'. Ele alimenta um conjunto que contém todos esses símbolos para o -gt operador para compará-los com 'a'. A saída é uma matriz vazia.

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

Se os dois lados dos operadores não forem razoavelmente comparáveis, esses operadores gerarão um erro de não encerramento.

Operadores correspondentes

Os operadores correspondentes (-like, -notlike, -matche -notmatch) encontram elementos que correspondem ou não correspondem a um padrão especificado. O padrão para -like e -notlike é uma expressão curinga (contendo *, ?e [ ]), enquanto -match e -notmatch aceitam uma expressão regular (Regex).

A sintaxe do é:

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

Quando a entrada desses operadores é um valor escalar, eles retornam um valor booliano .

Quando a entrada é uma coleção de valores, cada item na coleção é convertido em uma cadeia de caracteres para comparação. Os operadores e -notmatch retornam todos os -match membros correspondentes e não correspondentes, respectivamente. No entanto, os -like operadores e -notlike retornam os membros como cadeias de caracteres. A cadeia de caracteres retornada para um membro da coleção por -like e -notlike é a cadeia de caracteres que o operador usou para a comparação e é obtida convertendo o membro em uma cadeia de caracteres.

-like e -notlike

-like e -notlike se comportam de forma semelhante a -eq e -ne, mas o lado direito pode ser uma cadeia de caracteres que contém caracteres curinga.

Exemplo:

"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 e -notmatch

-match e -notmatch usam expressões regulares para pesquisar padrão nos valores do lado esquerdo. Expressões regulares podem corresponder a padrões complexos, como endereços de email, caminhos UNC ou números de telefone formatados. A cadeia de caracteres do lado direito deve aderir às regras de expressões regulares .

Exemplos escalares:

# 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

Se a entrada for uma coleção, os operadores retornarão os membros correspondentes dessa coleção.

Exemplos de coleção:

"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 e -notmatch dão suporte a grupos de captura regex. Cada vez que eles são executados na entrada escalar e o -match resultado é True ou o -notmatch resultado é False, eles substituem a $Matches variável automática. $Matches é uma tabela de hash que sempre tem uma chave chamada '0', que armazena toda a correspondência. Se a expressão regular contiver grupos de captura, o $Matches conterá chaves adicionais para cada grupo.

É importante observar que a $Matches tabela de hash contém apenas a primeira ocorrência de qualquer padrão correspondente.

Exemplo:

$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

Quando o -match resultado é False ou o -notmatch resultado é True ou quando a entrada é uma coleção, a $Matches variável automática não é substituída. Consequentemente, ele conterá o valor definido anteriormente ou $null se a variável não tiver sido definida. Ao fazer referência $Matches após invocar um desses operadores, considere verificar se a variável foi definida pela invocação do operador atual usando uma instrução condition.

Exemplo:

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

Para obter detalhes, consulte about_Regular_Expressions e about_Automatic_Variables.

Operador replacement

Substituição por expressões regulares

Como -match, o -replace operador usa expressões regulares para localizar o padrão especificado. Mas, ao contrário -matchde , ele substitui as correspondências por outro valor especificado.

Sintaxe:

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

O operador substitui todo ou parte de um valor pelo valor especificado usando expressões regulares. Você pode usar o operador para muitas tarefas administrativas, como renomear arquivos. Por exemplo, o comando a seguir altera as extensões de nome de arquivo de todos os .txt arquivos para .log:

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

Por padrão, o -replace operador não diferencia maiúsculas de minúsculas. Para diferenciar maiúsculas de minúsculas, use -creplace. Para torná-lo explicitamente que não diferencia maiúsculas de minúsculas, use -ireplace.

Exemplos:

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

Cook
book

A partir do PowerShell 7.2, quando o operando à esquerda em uma -replace instrução de operador não é uma cadeia de caracteres, esse operando é convertido em uma cadeia de caracteres. O PowerShell faz uma conversão de cadeia de caracteres que não diferencia a cultura.

Por exemplo, se sua cultura estiver definida como francês (fr), a conversão de valor 1.2 de cadeia de caracteres sensível à cultura será 1,2.

Antes do PowerShell 7.2:

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

No PowerShell 7.2 e posterior:

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

Substituições de expressões regulares

Também é possível usar expressões regulares para substituir dinamicamente o texto usando grupos de captura e substituições. Os grupos de captura podem ser referenciados na <substitute> cadeia de caracteres usando o caractere cifrão ($) antes do identificador de grupo.

No exemplo a seguir, o -replace operador aceita um nome de usuário na forma de DomainName\Username e converte no Username@DomainName formato :

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

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

John.Doe@Contoso.local

Aviso

O $ caractere tem funções sintáticas no PowerShell e em expressões regulares:

No PowerShell, entre aspas duplas, ele designa variáveis e atua como um operador de subexpressão.
Em cadeias de caracteres de pesquisa regex, ele denota o fim da linha.
Em cadeias de caracteres de substituição regex, ele denota grupos capturados. Coloque suas expressões regulares entre aspas simples ou insira um caractere de acento grave (`) antes delas.

Por exemplo:

$1 = 'Goodbye'

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

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

$$ em Regex denota um literal $. Isso $$ na cadeia de caracteres de substituição para incluir um literal $ na substituição resultante. Por exemplo:

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

Para saber mais, confira about_Regular_Expressions e Substituições em expressões regulares.

Substituindo em uma coleção

Quando o <input> para o operador é uma coleção, o -replace PowerShell aplica a substituição a cada valor na coleção. Por exemplo:

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

Substituição por um bloco de script

No PowerShell 6 e posterior, o -replace operador também aceita um bloco de script que executa a substituição. O bloco de script é executado uma vez para cada correspondência.

Sintaxe:

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

No bloco de script, use a $_ variável automática para acessar o texto de entrada que está sendo substituído e outras informações úteis. O tipo de classe dessa variável é System.Text.RegularExpressions.Match.

O exemplo a seguir substitui cada sequência de três dígitos pelos equivalentes de caractere. O bloco de script é executado para cada conjunto de três dígitos que precisa ser substituído.

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

Hello

Operadores de contenção

Os operadores de contenção (-contains, -notcontains, -ine -notin) são semelhantes aos operadores de igualdade, exceto que eles sempre retornam um valor booliano , mesmo quando a entrada é uma coleção. Esses operadores param de comparar assim que detectam a primeira correspondência, enquanto os operadores de igualdade avaliam todos os membros de entrada. Em uma coleção muito grande, esses operadores retornam mais rápido do que os operadores de igualdade.

-contains e -notcontains

Sintaxe:

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

Esses operadores informam se um conjunto inclui um determinado elemento. -contains retorna True quando o lado direito (objeto escalar) corresponde a um dos elementos no conjunto. -notcontains retorna False em vez disso.

Exemplos:

"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

Exemplos mais complexos:

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

$DomainServers -contains $thisComputer
# Output: True

Quando o operando do lado direito é uma coleção, esses operadores convertem o valor em sua representação de cadeia de caracteres antes de compará-lo à coleção do lado esquerdo.

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

Sintaxe:

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

Os -in operadores e -notin foram introduzidos no PowerShell 3 como o inverso sintático dos operadores de -contains e -notcontains . -in retorna True quando o lado <scalar-object> esquerdo corresponde a um dos elementos na coleção. -notin retorna False em vez disso.

Os exemplos a seguir fazem a mesma coisa que os exemplos para -contains e -notcontains fazem, mas são escritos com -in e -notin em vez disso.

"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

Exemplos mais complexos:

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

$thisComputer -in $DomainServers
# Output: True

Quando o operando do lado esquerdo é uma coleção, esses operadores convertem o valor em sua representação de cadeia de caracteres antes de compará-lo à coleção do lado direito.

$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

Comparação de tipos

Os operadores de comparação de tipos (-is e -isnot) são usados para determinar se um objeto é um tipo específico.

Sintaxe:

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

Exemplo:

$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

Compartilhar via

about_Comparison_Operators

Descrição breve

Descrição longa

Recursos comuns

Operadores de igualdade

-eq e -ne

-gt, -ge, -lt e -le

Operadores correspondentes

-like e -notlike

-match e -notmatch

Operador replacement

Substituição por expressões regulares

Substituições de expressões regulares

Substituindo em uma coleção

Substituição por um bloco de script

Operadores de contenção

-contains e -notcontains

-in e -notin

Comparação de tipos

Confira também

Recursos adicionais