sobre_Operadores_de_Comparação

Breve descrição

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 encontrar valores que correspondam a padrões especificados. O PowerShell inclui os seguintes operadores de comparação:

Igualdade

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

Correspondência

• -like, -ilike, -clike - string corresponde ao padrão curinga
• -notlike, -inotlike, -cnotlike - cadeia de caracteres 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

de substituição

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

de contenção

• -contains, -icontains, -ccontains - coleção contém um valor
• -notcontains, -inotcontains, -cnotcontains - coleção não contém um valor
• -in, -iin, -cin - o valor está numa coleção
• -notin, -inotin, -cnotin - o valor não está na 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 indiferenciação de maiúsculas e minúsculas, adicione um i após -. Por exemplo, -ieq é a versão explicitamente insensível a maiúsculas e minúsculas do -eq.

As comparações de cadeias de caracteres usam a InvariantCulture para comparações sensíveis a maiúsculas e minúsculas, e comparações que ignoram a diferença entre elas. As comparações são entre pontos de código unicode e não usam ordem de agrupamento específica da cultura. Os resultados são os mesmos, independentemente da cultura atual.

Quando o valor esquerdo na expressão de comparação é um valor escalar , o operador retorna um valor booleano . Quando o valor do lado esquerdo na expressão é uma coleção, o operador retorna os elementos da coleção que correspondem ao valor do lado direito da expressão. Os valores à direita são sempre tratados como instâncias únicas, mesmo quando são conjuntos. Os operadores de comparação não podem comparar efetivamente coleções com coleções.

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

Existem algumas exceções:

• Os operadores de contenção e tipo devolvem sempre um valor booleano
• O operador -replace devolve o resultado da substituição
• Os operadores -match e -notmatch também preenchem a variável automática $Matches, a 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; retorna Falso 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 filtra aqueles que não correspondem.

Exemplo:

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

Estes operadores processam todos os elementos da recolha. Exemplo:

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

zzz
zzz

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

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

PS> 1 -eq '1.0'
True

Neste exemplo, o valor 1 é convertido em uma cadeia de caracteres para ser comparado à 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 não é garantido que o resultado da comparação seja significativo para o utilizador 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 método retorna 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, você deve colocá$null no lado esquerdo do operador de igualdade. Colocá-lo no lado direito não faz o que você espera.

Por exemplo, seja $a uma matriz contendo elementos vazios:

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

O seguinte verifica se $a não é nulo.

$null -ne $a

True

O seguinte, no entanto, remove 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, -lte -le comportam-se de forma muito semelhante. Quando ambos os lados são escalares, retornam Verdadeiro ou Falso dependendo de como os dois lados se comparam.

Nos exemplos a seguir, todas as declaraçõ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, estes 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 trabalham 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 seja classificado depois de 'a'. Alimenta um conjunto contendo todos esses símbolos para que o operador -gt os compare 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, os operadores produzem um erro sem término.

Operadores de correspondência

Os operadores correspondentes (-like, -notlike, -matche -notmatch) encontram 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 aceita uma expressão regular (regex).

A sintaxe é:

<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 da coleção é convertido em uma cadeia de caracteres para comparação. Os operadores -match e -notmatch retornam todos os membros correspondentes e não correspondentes, respectivamente. No entanto, os operadores -like e -notlike retornam os membros como strings. 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 para 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 sequência de caracteres contendo os 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

Para obter melhores resultados, o -like lado direito dos operadores e -notlike deve ser um literal de cadeia de caracteres contendo a expressão curinga. O PowerShell passa a expressão curinga para o analisador de expressões curinga. Para corresponder a um dos caracteres curinga (*, , ou ?), você deve escapar dele com um caractere de backtick ([ ]`). Por exemplo, para corresponder a um literal ?, use `? na expressão curinga. Se você usar uma expressão de cadeia de caracteres expansível, o PowerShell expandirá a cadeia de caracteres antes de passá-la para o analisador curinga, o que resulta em caracteres sem escape sendo enviados como curingas.

# 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

-partida e -notmatch

-match e -notmatch usam 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 aderir às regras de expressões regulares .

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

É importante notar que a hashtable $Matches 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 resultado -match é False, ou o resultado -notmatch é True, ou quando a entrada é uma coleção, a variável automática $Matches não é sobrescrita. Consequentemente, ele conterá o valor definido anteriormente, ou $null se a variável não tiver sido definida. Ao fazer referência a $Matches depois de invocar um desses operadores, considere verificar se a variável foi definida pela invocação do operador atual usando uma instrução de condição.

Exemplo:

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

Para mais informações, consulte sobre_Expressões_Regulares e sobre_Variáveis_Automáticas.

Operador de substituição

Substituição por expressões regulares

Como -match, o operador -replace usa expressões regulares para localizar o padrão especificado. Mas, ao contrário de -match, substitui os resultados 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 arquivos .txt para .log:

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

Por padrão, o operador -replace não diferencia maiúsculas de minúsculas. Para diferenciar maiúsculas de minúsculas, use -creplace. Para torná-lo explicitamente insensí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 instrução de operador -replace não é uma cadeia de caracteres, esse operando é convertido em uma cadeia de caracteres. O PowerShell faz uma conversão de cadeia de caracteres insensível à cultura.

Por exemplo, se a sua cultura estiver definida como francês (fr), a conversão de cadeia de texto dependente da cultura do valor 1.2 será 1,2.

Antes do PowerShell 7.2:

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

No PowerShell 7.2 e versões posteriores:

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 captura de grupos e substituições. Os grupos de captura podem ser referenciados na cadeia de <substitute> usando o caractere de cifrão ($) antes do identificador de grupo.

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

$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 uma $literal. Use $$ na cadeia 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 sobre_expressões_regulares e substituições em expressões regulares.

Substituindo em uma colecção

Quando o operador de <input> para -replace é uma coleção, o PowerShell aplica a substituição a cada valor em toda a 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 posteriores, o -replace operador também aceita um bloco de scripts que executa a substituição. O bloco de scripts é executado uma vez por partida.

Sintaxe:

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

Dentro do bloco de scripts, use a $_ variável automática para aceder ao texto de entrada que está a ser substituído e a outras informações úteis. O tipo de classe desta 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 scripts executa-se para cada conjunto de três dígitos que precisa de ser substituído.

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

Hello

Operadores de confinamento

Os operadores de contenção (, , e ) 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 detetam a primeira correspondência, enquanto os operadores de igualdade avaliam todos os membros de entrada. Numa coleção muito grande, estes operadores retornam mais rapidamente do que os operadores de igualdade.

-contém e -notcontains

Sintaxe:

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

Esses operadores dizem se um conjunto inclui um determinado elemento. -contains retorna True quando o lado direito (objeto escalar) corresponde a um dos elementos do 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

-em e -notin

Sintaxe:

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

Os operadores -in e -notin foram introduzidos no PowerShell 3 como o reverso sintático dos operadores de -contains e -notcontains. -in retorna True quando o <scalar-object> do lado esquerdo corresponde a um dos elementos da coleção. -notin devolve Falso como alternativa.

Os exemplos a seguir fazem a mesma coisa que os exemplos para -contains e -notcontains, 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 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 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

Consulte também

• sobre_Booleans
• sobre_Operadores
• sobre_Expressões_Regulares
• sobre_Coringas
• Compare-Object
• ParaCada-Objeto
• Onde-objeto