TÓPICO

about_Comparison_Operators

DESCRIÇÃO RESUMIDA
Descreve os operadores que comparam valores no Windows PowerShell.

DESCRIÇÃO LONGA
Os operadores de comparação permitem que você especifique
condições para comparar valores e localizar valores que
correspondem a padrões especificados. Para usar um operador de
comparação, especifique os valores que deseja comparar juntamente
com um operador que separe esses valores.

Por padrão, todos os operadores de comparação não diferenciam

maiúsculas de minúsculas. Para tornar um operador de comparação
capaz de diferenciar maiúsculas de minúsculas, coloque "c" antes
do nome do operador.Por exemplo, a versão de "-eq" que diferencia
maiúsculas de minúsculas é "-ceq". Para tornar explícita a
incapacidade de diferenciar maiúsculas de minúsculas, coloque "i"
antes do operador. Por exemplo, a versão de "-eq" que explicitamente
não diferencia maiúsculas de minúsculas é "ieq".

Todos os operadores de comparação, com exceção dos operadores de

confinamento (-contains, -notcontains) e de tipo (-is, -isnot)
retornam um valor booleano quando a entrada do operador (o valor
no lado esquerdo dele) é um valor único (um escalar). Quando a
entrada é um conjunto de valores, os operadores de confinamento e os
operadores de tipo retornam qualquer valor correspondente. Se não houver
correspondências em um conjunto, esses operadores não retornam nada.
Os operadores de confinamento e operadores de tipo sempre retornam um
valor booleano.

O Windows PowerShell oferece suporte aos seguintes operadores de

comparação.

-eq
Descrição: igual a. Inclui um valor idêntico.
Exemplo:

C:\PS> "abc", "def" -eq "abc"

abc

-ne
Descrição: diferente de. Inclui um valor diferente.
Exemplo:

C:\PS> "abc", "def" -ne "abc"

def

-gt
Descrição: maior que.
 Exemplo:

C:\PS> 8 -gt 6
True

-ge
Descrição: maior ou igual a.
Exemplo:

C:\PS> 8 -ge 8
True

-lt
Descrição: menor que.
Exemplo:

C:\PS> 8 -lt 6
False

-le
Descrição: menor ou igual a.
Exemplo:

C:\PS> 6 -le 8
True

-like
Descrição: fazer correspondência usando o caractere curinga (*).
Exemplo:

C:\PS> "Windows PowerShell" -like "*shell"

True

-notlike
Descrição: não fazer correspondência usando o caractere curinga (*).
Exemplo:

C:\PS> "Windows PowerShell" -notlike "*shell"

False

-match
Descrição: faz a correspondência de uma cadeia de caracteres usando
expressões regulares. Quando a entrada é escalar, a variável
automática $Matches é preenchida.
Exemplo:
 C:\PS> "Domingo" -match "dom"
True

C:\PS> $matches
Nome Valor
---- -----
0 dom

-notmatch
Descrição: não corresponde a uma cadeia de caracteres. Usa
expressões regulares.
Quando a entrada é escalar, a variável automática
$Matches é preenchida.
Exemplo:

C:\PS> "Domingo" -notmatch "dom"

False

C:\PS> $matches
Nome Valor
---- -----
0 dom

-contains
Descrição: operador de confinamento. Inclui um valor idêntico
que não faz parte de um valor. Sempre retorna um valor booleano.
Exemplo:

C:PS> "abc", "def" -contains "def"

True

-notcontains
Descrição: operador de confinamento. Não inclui um valor
idêntico. Sempre retorna um valor booleano.
Exemplo:

C:PS> "Windows", "PowerShell" -notcontains "Shell"

True

-replace
Descrição: operador de substituição. Altera os elementos
especificados de um valor.
Exemplo:

C:\PS> "Get-Process" -replace "Get", "Stop"

Stop-Process

Operadores de igualdade
Os operadores de igualdade (-eq, -ne) retornam um valor igual a
 TRUE ou as correspondências quando um ou mais valores de entrada são
idênticos ao padrão especificado. O padrão inteiro deve corresponder
a um valor inteiro.

Os exemplos a seguir mostram o efeito do operador de igualdade:

C:PS> 1,2,3 -eq 2

2

C:PS> "PowerShell" -eq "Shell"

False

C:PS> "Windows", "PowerShell" -eq "Shell"

C:PS>

C:\PS> "abc", "def", "123" -eq "def"

def

Operadores de confinamento
Os operadores de confinamento (-contains e -notcontains) são
semelhantes aos operadores de igualdade. No entanto, os
operadores de confinamento sempre retornam um valor booleano,
mesmo que a entrada seja um conjunto.

Além disso, ao contrário dos operadores de igualdade, os

operadores de confinamento retornam um valor assim que detectam
a primeira correspondência. Os operadores de igualdade avaliam
todas as entradas e retornam todas as correspondências no conjunto.
Os exemplos a seguir mostram o efeito do operador -contains:

C:PS> 1,2,3 -contains 2

True

C:PS> "PowerShell" -contains "Shell"

False

C:PS> "Windows", "PowerShell" -contains "Shell"

False

C:\PS> "abc", "def", "123" -contains "def"

True

C:\PS> "verdadeiro", "azul", "seis" -contains "verdadeiro"

True

O exemplo a seguir mostra como os operadores de confinamento

diferem do operador igual a. Os operadores de confinamento
retornam um valor igual a TRUE na primeira correspondência.

C:\PS> 1,2,3,4,5,4,3,2,1 -eq 2

2
2
 C:\PS> 1,2,3,4,5,4,3,2,1 -contains 2
True

Em um conjunto muito grande, o operador -contains retorna

resultados mais rápido do que o operador igual a.

Operadores de correspondência
Os operadores de correspondência (-match e -notmatch) localizam
elementos que correspondem ou não a um padrão especificado
usando expressões regulares.

A sintaxe é:

<string[]> -match <expressão-regular>

<string[]> -notmatch <expressão-regular>

Os exemplos a seguir mostram alguns usos do operador -match:

C:\PS> "Windows", "PowerShell" -match ".shell"

PowerShell

C:\PS> (get-command get-member -syntax) -match "-view"

True

C:\PS> (get-command get-member -syntax) -notmatch "-path"

True

C:\PS> (get-content servers.txt) -match "^Servidor\d\d"

Server01
Server02

Os operadores de correspondência só pesquisam em cadeias de

caracteres. Eles não podem pesquisar em matrizes de inteiros ou
outros objetos.

Os operadores -match e -notmatch populam a variável automática

$Matches quando a entrada (o argumento do lado esquerdo) do
operador é um objeto escalar único. Quando a entrada é escalar, os
operadores -match e notmatch retornam um valor booleano e definem o
valor da variável automática $Matches para os componentes que
correspondem ao argumento.

Se a entrada for um conjunto, os operadores -match e -notmatch

retornam os membros correspondentes desse conjunto, mas o
operador não popula a variável $Matches.

Por exemplo, o comando a seguir envia um conjunto de cadeias de

caracteres para o operador -match. O operador -match retorna os
itens no conjunto que são correspondentes. Ele não popula a variável
automática $Matches.

C:\PS> "Domingo", "Segunda", "Terça" -match "dom"

Domingo
 C:\PS> $matches
C:\PS>

Por outro lado, o comando a seguir envia uma única cadeia de

caracteres para o operador -match. O operador -match retorna um
valor booleano e popula a variável automática $Matches.

C:\PS> "Domingo" -match "dom"

True

C:\PS> $matches

Nome Valor
---- -----
0 Dom

O operador -match popula a variável automática $Matches quando

a entrada é escalar e o resultado é False, ou seja, quando
detecta uma correspondência.

C:\PS> "Domingo" -notmatch "com"

True

C:\PS> $matches
C:\PS>

C:\PS> "Domingo" -notmatch "min"

False

C:\PS> $matches
C:\PS>

Nome Valor
---- -----
0 min

Operador de substituição
O operador -replace substitui um valor inteiro ou em parte pelo
valor especificado usando expressões regulares. Você pode usar
o operador -replace 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 .gif para .jpg:

Get-ChildItem | Rename-Item -NewName { $_ -replace '.gif$','.jpg$' }

A sintaxe do operador -replace é descrita a seguir. O espaço

reservado <original> representa os caracteres a serem
substituídos, e o espaço reservado <substituto> representa os
caracteres que os
substituirão:
 <entrada> <operador> <original>, <substituto>

Por padrão, o operador -replace não diferencia maiúsculas de

minúsculas. Para torná-lo capaz diferenciar maiúsculas de
minúsculas, use -creplace. Para torná-lo incapaz de diferenciar
maiúsculas de minúsculas explicitamente, use ireplace. Veja os
seguintes exemplos:

C:\PS> "book" -replace "B", "C"

Cook
C:\PS> "book" -ireplace "B", "C"
Cook
C:\PS> "book" -creplace "B", "C"
book

Operadores bit a bit

O Windows PowerShell fornece suporte aos operadores bit a bit
padrão, como os operadores AND bit a bit (-band) e OR bit a bit
inclusivo e exclusivo (-bor e -bxor). Desde o Windows
PowerShell 2.0, todos os operadores bit a bit funcionam com
inteiros de 64 bits.

O Windows PowerShell oferece suporte aos seguintes operadores

bit a bit.

Operador Descrição Exemplo

-------- ---------------------- -------------------
-band AND bit a bit C:\PS> 10 -band 3
2

-bor OR bit a bit (inclusivo) C:\PS> 10 -bor 3

11

-bxor OR bit a bit (exclusivo) C:\PS> 10 -bxor 3

9

Os operadores bit a bit atuam no formato binário de um valor.

Por exemplo, a estrutura de bits do número 10 é 00001010 (com
base em 1 byte) e a estrutura de bits do número 3 é 00000011.
Quando você usa um operador bit a bit para comparar 10 com 3,
os bits individuais em cada byte são comparados.

Em uma operação AND bit a bit, o bit resultante é definido como

1 apenas quando ambos os bits de entrada são 1.

00001010 (10)
00000011 ( 3)
------------------ bAND
00000010 ( 2)

Em uma operação OR bit a bit (inclusivo), o bit resultante é

 definido como 1 quando um ou ambos os bits de entrada equivalem
a 1. O bit resultante só é definido como 0 quando ambos os bits
de entrada são definidos como 0.

00001010 (10)
00000011 ( 3)
------------------ bOR (inclusivo)
00001011 (11)

Em uma operação OR bit a bit (exclusivo), o bit resultante é

definido como 1 apenas quando um bit de entrada é igual a 1.

00001010 (10)
00000011 ( 3)
------------------ bXOR (exclusivo)
00001001 ( 9)

CONSULTE TAMBÉM
about_Operators
about_Regular_Expressions
about_Wildcards
Compare-Object