about_Comparison_Operators
Aplica-se a: Windows PowerShell 2.0, Windows PowerShell 3.0, Windows PowerShell 4.0, Windows PowerShell 5.0
Insira a introdução aqui.
TÓPICO
about_Comparison_Operators
DESCRIÇÃO BREVE
Descreve os operadores que comparam valores no Windows PowerShell®.
DESCRIÇÃO LONGA
Operadores de comparação permitem especificar condições para comparar valores e encontrar os valores que correspondem a padrões especificados. Para usar um operador de comparação, especifique os valores que você deseja comparar com um operador que separa esses valores.
Windows PowerShell inclui os seguintes operadores de comparação:
-eq
-ne
-gt
-ge
-lt
-le
-Like
-NotLike
-Match
-NotMatch
-Contains
-NotContains
-In
-NotIn
-Replace
Por padrão, todos os operadores de comparação diferenciam maiúsculas de minúsculas. Para um operador de comparação que diferencia maiúsculas de minúsculas, preceda o nome do operador com um "c". Por exemplo, a versão de maiúsculas e minúsculas do "-eq" é "-ceq". Para torná-la explícita, preceda o operador com um "i". Por exemplo, a versão explicitamente maiúsculas e minúsculas do "-eq" é "-ieq".
Quando a entrada a um operador é um valor escalar, os operadores de comparação retornam um valor booleano. Quando a entrada é uma coleção de valores, os operadores de comparação retornam quaisquer valores correspondentes. Se não houver nenhuma correspondência em uma coleção, os operadores de comparação não retornam nada.
As exceções são os operadores de contenção (-Contains, -NotContains), os operadores in (-In, -NotIn) e os operadores de tipo (-Is, -IsNot), que sempre retornam um valor booleano.
Windows PowerShell suporta os seguintes operadores de comparação.
-eq
Descrição: Igual a. Inclui um valor idêntico.
Exemplo:
PS C:\> "abc" -eq "abc"
True
PS C:\> "abc" -eq "abc", "def"
False
PS C:\> "abc", "def" -eq "abc"
abc
-ne
Descrição: Não é igual a. Inclui um valor diferente.
Exemplo:
PS C:\> "abc" -ne "def"
True
PS C:\> "abc" -ne "abc"
False
PS C:\> "abc" -ne "abc", "def"
True
PS C:\> "abc", "def" -ne "abc"
def
-gt
Descrição: Maior-que.
Exemplo:
PS C:\> 8 -gt 6
True
PS C:\> 7, 8, 9 -gt 8
9
-ge
Descrição: Maior-que ou igual a.
Exemplo:
PS C:\> 8 -ge 8
True
PS C:\> 7, 8, 9 -ge 8
8
9
-lt
Descrição: Menor-que.
Exemplo:
PS C:\> 8 -lt 6
False
PS C:\> 7, 8, 9 -lt 8
7
-le
Descrição: Menor-que ou igual a.
Exemplo:
PS C:\> 6 -le 8
True
PS C:\> 7, 8, 9 -le 8
7
8
-Como
Descrição: Correspondência usando o caractere curinga (*).
Exemplo:
PS C:\> "Windows PowerShell" -like "*shell"
True
PS C:\> "Windows PowerShell", "Server" -like "*shell"
Windows PowerShell
-NotLike
Descrição: Não correspondência usando o caractere curinga (*).
Exemplo:
PS C:\> "Windows PowerShell" -NotLike "*shell"
False
PS C:\> "Windows PowerShell", "Server" -NotLike "*shell"
Server
-Match
Descrição: Corresponde a uma cadeia de caracteres usando expressões regulares. Quando a entrada é escalar, ele preenche a variável automática $Matches.
Exemplo:
PS C:\> "Sunday" -Match "sun"
True
PS C:\> $matches
Name Value
---- -----
0 Sun
PS C:\> "Sunday", "Monday" -Match "sun"
Sunday
-NotMatch
Descrição: Não corresponde a uma cadeia de caracteres. Usa expressões regulares. Quando a entrada é escalar, ele preenche a variável automática $Matches.
Exemplo:
PS C:\> "Sunday" -NotMatch "sun"
False
PS C:\> $matches
Name Value
---- -----
0 sun
PS C:\> "Sunday", "Monday" -NotMatch "sun"
Monday
-Contém
Descrição: Operador de contenção. Informa se uma coleção de valores de referência inclui um valor de teste único. Sempre retorna um valor booleano. Retorna verdadeiro somente quando o valor de teste corresponde exatamente a ao menos um dos valores de referência.
Quando o valor de teste é uma coleção, o operador Contains usa igualdade de referência. Retorna TRUE somente quando um dos valores de referência é a mesma instância do objeto de valor de teste.
Sintaxe:
<Reference-values> -Contains <Test-value>
Exemplos:
PS C:\> "abc", "def" -Contains "def"
True
PS C:\> "Windows", "PowerShell" -Contains "Shell"
False #Not an exact match
# Does the list of computers in $domainServers
# include $thisComputer?
# -------------------------------------------
PS C:\> $domainServers -Contains $thisComputer
True
PS C:\> "abc", "def", "ghi" -Contains "abc", "def"
False
PS C:\> $a = "abc", "def"
PS C:\> "abc", "def", "ghi" -Contains $a
False
PS C:\> $a, "ghi" -Contains $a
True
-NotContains
Descrição: Operador de contenção. Informa se uma coleção de valores de referência inclui um valor de teste único. Sempre retorna um valor booleano. Retorna TRUE quando o valor de teste não é uma correspondência exata para pelo menos um dos valores de referência.
Quando o valor de teste é uma coleção, o operador NotContains usa igualdade de referência.
Sintaxe:
<Reference-values> -NotContains <Test-value>
Exemplos:
PS C:\> "Windows", "PowerShell" -NotContains "Shell"
True #Not an exact match
# Get cmdlet parameters, but exclude common parameters
function get-parms ($cmdlet)
{
$Common = "Verbose", "Debug", "WarningAction", "WarningVariable", `
"ErrorAction", "ErrorVariable", "OutVariable", "OutBuffer"
$allparms = (Get-Command $Cmdlet).parametersets | foreach {$_.Parameters} | `
foreach {$_.Name} | Sort-Object | Get-Unique
$allparms | where {$Common -NotContains $_ }
}
# Find unapproved verbs in the functions in my module
# -------------------------------------------
PS C:\> $ApprovedVerbs = Get-Verb | foreach {$_.verb}
PS C:\> $myVerbs = Get-Command -Module MyModule | foreach {$_.verb}
PS C:\> $myVerbs | where {$ApprovedVerbs -NotContains $_}
ForEach
Sort
Tee
Where
-In
Descrição: Operador in. Informa se um valor de teste aparece em uma coleção de valores de referência. Sempre retorna como valor booliano. Retorna verdadeiro somente quando o valor de teste corresponde exatamente a ao menos um dos valores de referência.
Quando o valor de teste é uma coleção, o operador In usa igualdade de referência. Retorna TRUE somente quando um dos valores de referência é a mesma instância do objeto de valor de teste.
O operador In foi introduzido no Windows PowerShell 3.0.
Sintaxe:
<Test-value> -in <Reference-values>
Exemplos:
PS C:\> "def" -in "abc", "def"
True
PS C:\> "Shell" -in "Windows", "PowerShell"
False #Not an exact match
PS C:\> "Windows" -in "Windows", "PowerShell"
True #An exact match
PS C:\> "Windows", "PowerShell" -in "Windows", "PowerShell", "ServerManager"
False #Using reference equality
PS C:\> $a = "Windows", "PowerShell"
PS C:\> $a -in $a, "ServerManager"
True #Using reference equality
# Does the list of computers in $domainServers
# include $thisComputer?
# -------------------------------------------
PS C:\> $thisComputer -in $domainServers
True
-NotIn
Descrição: Operador de NotIn. Informa se um valor de teste aparece em uma coleção de valores de referência. Sempre retorna um valor booleano. Retorna TRUE quando o valor de teste não é uma correspondência exata para pelo menos um dos valores de referência.
Quando o valor de teste é uma coleção, o operador In usa igualdade de referência. Retorna TRUE somente quando um dos valores de referência é a mesma instância do objeto de valor de teste.
O operador NotIn foi introduzido no Windows PowerShell 3.0.
Sintaxe:
<Test-value> -NotIn <Reference-values>
Exemplos:
PS C:\> "def" -NotIn "abc", "def"
False
PS C:\> "ghi" -NotIn "abc", "def"
True
PS C:\> "Shell" -NotIn "Windows", "PowerShell"
True #Not an exact match
PS C:\> "Windows" -NotIn "Windows", "PowerShell"
False #An exact match
# Find unapproved verbs in the functions in my module
# -------------------------------------------
PS C:\> $ApprovedVerbs = Get-Verb | foreach {$_.verb}
PS C:\> $myVerbs = Get-Command -Module MyModule | foreach {$_.verb}
PS C:\> $myVerbs | where {$_ -NotIn $ApprovedVerbs}
ForEach
Sort
Tee
Where
-Substituir
Descrição: Substitui o operador. Altera os elementos especificados de um valor
Exemplo:
PS C:\> "Get-Process" -Replace "Get", "Stop"
Stop-Process
# Change all .GIF file name extension to .JPG
PS C:\> dir *.gif | foreach {$_ -Replace ".gif", ".jpg"}
OPERADORES DE IGUALDADE
Os operadores de igualdade (-eq, ne-) retornam um valor de TRUE ou as correspondências quando um ou mais dos valores de entrada são idênticos ao padrão especificado. O padrão inteiro deve corresponder a um valor inteiro.
C:PS> 2 -eq 2
True
C:PS> 2 -eq 3
False
C:PS> 1,2,3 -eq 2
2
C:PS> "PowerShell" -eq "Shell"
False
C:PS> "Windows", "PowerShell" -eq "Shell"
C:PS>
PS C:\> "abc", "def", "123" -eq "def"
def
PS C:\> "abc", "def", "123" -ne "def"
abc
123
OPERADORES DE CONTENÇÃO
Os operadores de contenção (-Contains e - NotContains) são semelhantes aos operadores de igualdade. No entanto, os operadores de confinamento sempre retornam um valor booleano, mesmo quando a entrada é uma coleção.
Além disso, ao contrário dos operadores de igualdade, os operadores de confinamento retornarem um valor tão logo eles detectam a primeira correspondência. Os operadores de igualdade avaliam todas as entradas e, em seguida, retornam todas as correspondências na coleção. 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
PS C:\> "abc", "def", "123" -contains "def"
True
PS C:\> "true", "blue", "six" -contains "true"
True
O exemplo a seguir mostra como os operadores de confinamento diferem do equivalente ao operador. Os operadores de confinamento retornam um valor TRUE na primeira correspondência.
PS C:\> 1,2,3,4,5,4,3,2,1 -eq 2
2
2
PS C:\> 1,2,3,4,5,4,3,2,1 -contains 2
True
Em uma coleção muito grande, o operador -Contains retorna resultados mais rápido do que o operador de igualdade.
Operadores de correspondência
Os operadores de correspondência (-Match e - NotMatch) localizam elementos que correspondem ou que não correspondem a um padrão especificado usando expressões regulares.
A sintaxe é:
<string[]> -Match <regular-expression>
<string[]> -NotMatch <regular-expression>
Os exemplos a seguir mostram alguns usos do operador -Match:
PS C:\> "Windows", "PowerShell" -Match ".shell"
PowerShell
PS C:\> (Get-Command Get-Member -Syntax) -Match "-view"
True
PS C:\> (Get-Command Get-Member -Syntax) -NotMatch "-path"
True
PS C:\> (Get-Content Servers.txt) -Match "^Server\d\d"
Server01
Server02
Os operadores de correspondência pesquisam somente em cadeias de caracteres. Eles não podem pesquisar em matrizes de inteiros ou outros objetos.
Os operadores -Match e -NotMatch preenchem a variável automática $Matches quando a entrada (o argumento do lado esquerdo) para o operador é um único objeto escalar. Quando a entrada é escalar, os operadores -Match e -NotMatch retornam um valor booleano e definem o valor da variável automática $Matches em relação aos componentes correspondentes do argumento.
Se a entrada for uma coleção, os operadores -Match e NotMatch retornam os membros correspondentes da coleção, mas o operador não preenche a variável $Matches.
Por exemplo, o comando a seguir envia uma coleção de cadeias de caracteres para o operador -Match. O operador -Match retorna os itens da coleção que correspondem. Ele não preenche a variável automática $Matches.
PS C:\> "Sunday", "Monday", "Tuesday" -Match "sun"
Sunday
PS C:\> $matches
PS C:\>
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 preenche a variável automática $Matches.
PS C:\> "Sunday" -Match "sun"
True
PS C:\> $matches
Name Value
---- -----
0 Sun
O operador - NotMatch preenche a variável automática $Matches quando a entrada é escalar e o resultado é False, ou seja, quando ele detecta uma correspondência.
PS C:\> "Sunday" -NotMatch "rain"
True
PS C:\> $matches
PS C:\>
PS C:\> "Sunday" -NotMatch "day"
False
PS C:\> $matches
PS C:\>
Name Value
---- -----
0 day
OPERADORES DE SUBSTITUIÇÃO
O operador -Replace substitui todo ou parte de um valor com o valor especificado usando expressões regulares. Você pode usar o operador -Replace para muitas tarefas administrativas, como renomear os 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 é a seguinte, na qual o espaço reservado <original> representa os caracteres a serem substituídos, e o espaço reservado <substituir> representa os caracteres que os substituirão:
<input> <operator> <original>, <substitute>
Por padrão, o operador -Replace diferencia maiúsculas de minúsculas. Para torná-lo entre maiúsculas e minúsculas, use - cReplace. Para torná-lo explicitamente maiúsculas de minúsculas, use -iReplace. Considere os exemplos a seguir:
PS C:\> "book" -Replace "B", "C"
Cook
PS C:\> "book" -iReplace "B", "C"
Cook
PS C:\> "book" -cReplace "B", "C"
book
PS C:\> '<command:parameter required="false" variableLength="true" globbing="false"'`
| foreach {$_ -replace 'globbing="false"', 'globbing="true"'}
<command:parameter required="false" variableLength="true" globbing="true"
Operadores bit a bit
Windows PowerShell oferece suporte a operadores bit a bit padrão, incluindo o bit a bit- AND (-bAnd), os operadores OR bit a bit inclusivos e exclusivos (-bOr e - bXor) e NOT bit a bit (-bNot).
A partir de Windows PowerShell 2.0, todos os operadores bit a bit trabalham com números inteiros de 64 bits.
A partir de Windows PowerShell 3.0, o -shr (deslocamento para a direita) e - shl (deslocamento para a esquerda) são introduzidos para dar suporte à aritmética bit a bit em Windows PowerShell.
Windows PowerShell suporta os seguintes operadores bit a bit.
Operator Description Example
-------- ---------------------- -------------------
-bAnd Bitwise AND PS C:\> 10 -band 3
2
-bOr Bitwise OR (inclusive) PS C:\> 10 -bor 3
11
-bXor Bitwise OR (exclusive) PS C:\> 10 -bxor 3
9
-bNot Bitwise NOT PS C:\> -bNot 10
-11
-shl Shift-left PS C:\> 100 -shl 2
400
-shr Shift-right PS C:\> 100 -shr 1
50
Os operadores bit a bit atuam em formato binário de um valor. Por exemplo, a estrutura de bit para o número 10 é 00001010 (baseado em 1 byte), e a estrutura de bit para o número 3 é 00000011. Quando um operador bit a bit é usado para comparar 10 a 3, os bits individuais em cada bite são comparados.
Em uma operação AND bit a bit, o bit resultante é definido como 1 somente quando ambos os bits de entrada são 1.
1010 (10)
0011 ( 3)
-------------- bAND
0010 ( 2)
Em uma operação OR bit a bit (inclusiva), o bit resultante é definido como 1 somente quando ambos os bits de entrada são 1. O bit resultante é definido para 0 quando ambos os bits de entrada são definidos como 0.
1010 (10)
0011 ( 3)
-------------- bOR (inclusive)
1011 (11)
Em uma operação bit a bit OU (exclusiva), o bit resultante é definido como 1 somente quando um bit de entrada é 1.
1010 (10)
0011 ( 3)
-------------- bXOR (exclusive)
1001 ( 9)
O operador bit a bit não é um operador unário que produz o complemento binário do valor. Um bit de 1 é definido como 0 e um bit de 0 é definido como 1.
Por exemplo, o complemento binário 0 é -1, o máximo inteiro não assinado (0xffffffff), e o complemento binário de -1 é 0.
PS C:\> -bNOT 10
-11
0000 0000 0000 1010 (10)
------------------------- bNOT
1111 1111 1111 0101 (-11, xfffffff5)
Em uma operação de deslocamento para a esquerda bit a bit, todos os bits são movidos "n" casas à esquerda, em que "n" é o valor do operando à direita. Um zero é inserido nos locais.
Quando o operando esquerdo é um valor inteiro (32 bits), 5 bits inferiores do operando à direita determinam quantos bits do operando esquerdo são deslocados.
Quando o operando esquerdo é um valor longo (64 bits), 6 bits inferiores do operando à direita determinam quantos bits do operando esquerdo são deslocados.
PS C:\> 21 -shl 1
42
00010101 (21)
00101010 (42)
PS C:\> 21 -shl 2
84
00010101 (21)
00101010 (42)
01010100 (84)
Em uma operação de deslocamento para a direita bit a bit, todos os bits são movidos "n" casas à direita, em que "n" é o valor do operando à direita. O operador de deslocamento para a direita (-shr) insere um zero no local mais à esquerda ao deslocar um valor positivo ou não assinado à direita.
Quando o operando esquerdo é um valor inteiro (32 bits), 5 bits inferiores do operando à direita determinam quantos bits do operando esquerdo são deslocados.
Quando o operando esquerdo é um valor longo (64 bits), 6 bits inferiores do operando à direita determinam quantos bits do operando esquerdo são deslocados.
PS C:\> 21 -shr 1
10
00010101 (21)
00001010 (10)
PS C:\> 21 -shr 2
5
00010101 (21)
00001010 (10)
00000101 ( 5)
CONSULTE TAMBÉM
about_Operators
about_Regular_Expressions
about_Wildcards
Compare-Object
ForEach-Object
Where-Object