about_Comparison_Operators

Descrição breve

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

Descrição longa

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

Igualdade

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

Correspondência

• -like, -ilike, -clike - string corresponde ao padrão curinga
• -notlike, -inotlike, -cnotlike - string não corresponde ao padrão curinga
• -match, -imatch, -cmatch - string corresponde ao padrão regex
• -notmatch, -inotmatch, -cnotmatch - string não corresponde ao padrão regex

Substituição

• -replace, -ireplace, -creplace - substitui cadeias de caracteres correspondentes a um padrão regex

Contenção

• -contains, -icontains, -ccontains - coleção contém um valor
• -notcontains, -inotcontains, -cnotcontains - coleção não contém um valor
• -in - 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

Características 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 sensível a maiúsculas e minúsculas, adicione um c após o -. Por exemplo, -ceq é a versão que diferencia maiúsculas de minúsculas do -eq. Para tornar explícita a diferenciação de maiúsculas e minúsculas, adicione um i após -. Por exemplo, -ieq é a versão explicitamente sem distinção entre maiúsculas e minúsculas do -eq.

As comparações de cadeia de caracteres usam o 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 agrupamento 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 booleano . 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 booleano
• O -replace operador retorna o resultado da substituição
• Os -match operadores e -notmatch também preenchem a variável automática, a $Matches menos que o lado esquerdo da expressão seja uma coleção.

Operadores de igualdade

-eq e -ne

Quando o lado esquerdo é escalar, -eq retorna True se o lado direito for equivalente, caso contrário, -eq retorna False. -ne faz o contrário; ele retorna False quando ambos os lados são equivalentes, caso contrário, -ne retorna 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 equality pode comparar objetos de diferentes tipos. É importante entender que o valor no lado direito da comparação pode ser convertido para o 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 quaisquer dois objetos, não apenas um escalar ou coleção. Mas o resultado da comparação não é garantido como 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 é Falso 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ê precisa determinar se uma variável é $null, você deve colocar $null no lado esquerdo do operador de igualdade. Colocá-lo do lado direito não faz o que você espera.

Por exemplo, vamos $a ser uma matriz contendo elementos nulos:

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

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

$null -ne $a

True

O seguinte, no entanto, arquiva todos os elementos nulos de $a:

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

1
2
4
6

-gt, -ge, -lt e -le

-gt, -ge, -lt, e -le comportam-se de forma muito semelhante. Quando ambos os lados são escalares, eles retornam Verdadeiro ou Falso 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

Quando o lado esquerdo é uma coleção, esses operadores comparam cada membro da coleção com o lado direito. Dependendo de sua 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 implementa 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 é classificado após 'a'. Ele alimenta um conjunto contendo todos esses símbolos para o -gt operador 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 terminação.

Operadores correspondentes

Os operadores correspondentes (-like, -notlike, -matche -notmatch) localizam elementos que correspondem ou não a um padrão especificado. O padrão para -like e -notlike é uma expressão curinga (contendo *, ?e [ ]), enquanto -match e -notmatch aceitar 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 booleano .

Quando a entrada é uma coleção de valores, cada item na coleção é convertido em uma cadeia de caracteres para comparação. Os -match operadores e -notmatch retornam todos os 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 comportar-se de forma semelhante a -eq e -ne, mas o lado direito poderia ser uma cadeia de caracteres contendo curingas.

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 use expressões regulares para procurar padrões nos valores do lado esquerdo. As expressões regulares podem corresponder a padrões complexos, como endereços de e-mail, caminhos UNC ou números de telefone formatados. A cadeia de caracteres do lado direito deve seguir as 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 suporte a grupos de captura de regex. Cada vez que eles são executados na entrada escalar, e o -match resultado é True, ou o -notmatch resultado é False, eles sobrescrevem a $Matches variável automática. $Matches é uma Hashtable 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 hashtable 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 $Matches referência depois de 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 de substituição

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 -matchdo , 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 operador não diferencia maiúsculas -replace de minúsculas. Para torná-lo sensível a maiúsculas e minúsculas, use -creplace. Para torná-lo explicitamente sensível a maiúsculas e 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 esquerdo em uma -replace instrução operator não é uma cadeia de caracteres, esse operando é convertido em uma cadeia de caracteres. O PowerShell faz uma conversão de cadeia de caracteres sem diferenciação cultural.

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 <substitute> na 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 para o Username@DomainName formato:

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

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

John.Doe@Contoso.local

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, consulte about_Regular_Expressions e substituições em expressões regulares.

Substituindo em uma coleção

Quando o <input> operador to é -replace uma coleção, o 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 partida.

Sintaxe:

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

Dentro do 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 caracteres. 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 booleano , 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 um acervo 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 com a 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 reverso sintático dos operadores de -contains e -notcontains . -in retorna True quando o lado <scalar-object> esquerdo corresponde a um dos elementos da 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 eles 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 com a 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 tipo (-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

Confira também

• about_Booleans
• about_Operators
• about_Regular_Expressions
• about_Wildcards
• Compare-Object
• Foreach-Object
• Where-Object