Sobre operadores de comparação
Descrição breve
Descreve os operadores que comparam valores no PowerShell.
Descrição longa
Os operadores de comparação permitem que você especifique condições para comparar valores e localizar valores que correspondam aos padrões especificados. Para usar um operador de comparação, especifique os valores que você deseja comparar com um operador que separa esses valores.
O PowerShell inclui os seguintes operadores de comparação:
| Tipo | Operadores | Descrição |
|---|---|---|
| Igualitário | -eq | equals |
| -ne | não é igual a | |
| -gt | maior que | |
| -ge | maior ou igual | |
| -lt | menor que | |
| -le | menor ou igual | |
| Matching | -like | Retorna true quando a cadeia de caracteres corresponde a curinga |
| pattern | ||
| -notlike | Retorna true quando a cadeia de caracteres não corresponde | |
| padrão curinga | ||
| -match | Retorna true quando a cadeia de caracteres corresponde ao regex | |
| padrão; $matches contém cadeias de caracteres correspondentes | ||
| -notmatch | Retorna true quando a cadeia de caracteres não corresponde | |
| padrão regex; $matches contém correspondência | ||
| cadeias de caracteres | ||
| Contenção | -contains | Retorna true quando o valor de referência contido |
| em uma coleção | ||
| -notcontains | Retorna true quando o valor de referência não | |
| contido em uma coleção | ||
| -in | Retorna true quando o valor de teste contido em um | |
| collection | ||
| -notin | Retorna true quando o valor de teste não está contido | |
| em uma coleção | ||
| Substituição | -replace | Substitui um padrão de cadeia de caracteres |
| Tipo | -is | Retorna true se ambos os objetos forem os mesmos |
| type | ||
| -isnot | Retornará true se os objetos não forem os mesmos | |
| type |
Por padrão, todos os operadores de comparação não diferenciam maiúsculas de minúsculas. Para tornar 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 que diferencia maiúsculas de minúsculas -eq é -ceq. Para tornar a insensibilidade de maiúsculas de minúsculas explícita, preceda o operador com um i. Por exemplo, a versão explicitamente sem diferenciação de maiúsculas de minúsculas -eq é -ieq.
Quando a entrada para um operador é um valor escalar, os operadores de comparação retornam um valor booliano. Quando a entrada é uma coleção de valores, os operadores de comparação retornam valores correspondentes. Se não houver correspondências em uma coleção, os operadores de comparação retornarão uma matriz vazia.
PS> (1, 2 -eq 3).GetType().FullName
System.Object[]
As exceções são os operadores de contenção, os operadores In e os operadores de tipo, que sempre retornam um valor booliano .
Observação
Se você precisar comparar um valor com $null você deve colocar $null no lado esquerdo da comparação. Quando você compara com $null um Objeto[] o resultado é False porque o objeto de comparação é uma matriz. Quando você compara uma matriz com $null, a comparação filtra todos $null os valores armazenados na matriz. Por exemplo:
PS> $null -ne $null, "hello"
True
PS> $null, "hello" -ne $null
hello
Operadores de igualdade
Os operadores de igualdade (-eq, -ne) retornam um valor true ou as correspondências quando um ou mais dos valores de entrada são idênticos ao padrão especificado. Todo o padrão deve corresponder a um valor inteiro.
Exemplo:
-eq
Descrição: igual a. Inclui um valor idêntico.
Exemplo:
PS> 2 -eq 2
True
PS> 2 -eq 3
False
PS> 1,2,3 -eq 2
2
PS> "abc" -eq "abc"
True
PS> "abc" -eq "abc", "def"
False
PS> "abc", "def" -eq "abc"
abc
-ne
Descrição: não é igual a. Inclui um valor diferente.
Exemplo:
PS> "abc" -ne "def"
True
PS> "abc" -ne "abc"
False
PS> "abc" -ne "abc", "def"
True
PS> "abc", "def" -ne "abc"
def
-gt
Descrição: maior que.
Exemplo:
PS> 8 -gt 6
True
PS> 7, 8, 9 -gt 8
9
Observação
Isso não deve ser confundido com >o operador maior do que em muitas outras linguagens de programação. No PowerShell, > é usado para redirecionamento. Para obter mais informações, consulte About_redirection.
-ge
Descrição: maior ou igual a.
Exemplo:
PS> 8 -ge 8
True
PS> 7, 8, 9 -ge 8
8
9
-lt
Descrição: menor que.
Exemplo:
PS> 8 -lt 6
False
PS> 7, 8, 9 -lt 8
7
-le
Descrição: menor ou igual a.
Exemplo:
PS> 6 -le 8
True
PS> 7, 8, 9 -le 8
7
8
Operadores correspondentes
Os operadores like (-like e -notlike) encontram elementos que correspondem ou não correspondem a um padrão especificado usando expressões curinga.
A sintaxe do é:
<string[]> -like <wildcard-expression>
<string[]> -notlike <wildcard-expression>
Os operadores de correspondência (-match e -notmatch) encontram elementos que correspondem ou não correspondem a um padrão especificado usando expressões regulares.
Os operadores de correspondência preenchem a $Matches variável automática quando a entrada (o argumento do lado esquerdo) para o operador é um único objeto escalar. Quando a entrada é escalar, e os -match-notmatch operadores retornam um valor booliano e definem o valor da $Matches variável automática para os componentes correspondentes do argumento.
A sintaxe do é:
<string[]> -match <regular-expression>
<string[]> -notmatch <regular-expression>
-like
Descrição: corresponder usando o caractere curinga (*).
Exemplo:
PS> "PowerShell" -like "*shell"
True
PS> "PowerShell", "Server" -like "*shell"
PowerShell
-notlike
Descrição: não corresponde ao uso do caractere curinga (*).
Exemplo:
PS> "PowerShell" -notlike "*shell"
False
PS> "PowerShell", "Server" -notlike "*shell"
Server
-match
Descrição: corresponde a uma cadeia de caracteres usando expressões regulares. Quando a entrada é escalar, ela preenche a $Matches variável automática.
Se a entrada for uma coleção, os operadores e -notmatch os -match operadores retornarão os membros correspondentes dessa coleção, mas o operador não preencherá a $Matches variável.
Por exemplo, o comando a seguir envia uma coleção de cadeias de caracteres para o -match operador. O -match operador retorna os itens na coleção que correspondem. Ele não preenche a $Matches variável automática.
PS> "Sunday", "Monday", "Tuesday" -match "sun"
Sunday
PS> $Matches
PS>
Por outro lado, o comando a seguir envia uma única cadeia de caracteres para o -match operador. O -match operador retorna um valor booliano e popula a $Matches variável automática. A $Matches variável automática é um Hashtable. Se nenhum agrupamento ou captura for usado, apenas uma chave será preenchida.
A 0 chave representa todo o texto correspondente. Para obter mais informações sobre agrupamento e captura usando expressões regulares, consulte about_Regular_Expressions.
PS> "Sunday" -match "sun"
True
PS> $Matches
Name Value
---- -----
0 Sun
É importante observar que o $Matches hashtable conterá apenas a primeira ocorrência de qualquer padrão correspondente.
PS> "Banana" -match "na"
True
PS> $Matches
Name Value
---- -----
0 na
Importante
A 0 chave é um Inteiro. Você pode usar qualquer método Hashtable para acessar o valor armazenado.
PS> "Good Dog" -match "Dog"
True
PS> $Matches[0]
Dog
PS> $Matches.Item(0)
Dog
PS> $Matches.0
Dog
O -notmatch operador preenche a $Matches variável automática quando a entrada é escalar e o resultado é False, que ele, quando detecta uma correspondência.
PS> "Sunday" -notmatch "rain"
True
PS> $matches
PS>
PS> "Sunday" -notmatch "day"
False
PS> $matches
Name Value
---- -----
0 day
-notmatch
Descrição: não corresponde a uma cadeia de caracteres. Usa expressões regulares. Quando a entrada é escalar, ela preenche a $Matches variável automática.
Exemplo:
PS> "Sunday" -notmatch "sun"
False
PS> $matches
Name Value
---- -----
0 sun
PS> "Sunday", "Monday" -notmatch "sun"
Monday
Operadores de contenção
Os operadores de contenção (-contains e -notcontains) são semelhantes aos operadores de igualdade. No entanto, os operadores de contenção sempre retornam um valor booliano, mesmo quando a entrada é uma coleção.
Além disso, ao contrário dos operadores de igualdade, os operadores de contenção retornam um valor assim que detectam a primeira correspondência. Os operadores de igualdade avaliam todas as entradas e retornam todas as correspondências na coleção.
-contains
Descrição: operador de contenção. Informa se uma coleção de valores de referência inclui um único valor de teste. Sempre retorna um valor booliano. Retorna TRUE somente quando o valor de teste corresponde exatamente a pelo menos um dos valores de referência.
Quando o valor de teste é uma coleção, o operador Contains usa a igualdade de referência. Ele retorna TRUE somente quando um dos valores de referência é a mesma instância do objeto de valor de teste.
Em uma coleção muito grande, o -contains operador retorna resultados mais rápidos do que o operador igual a.
Sintaxe:
<Reference-values> -contains <Test-value>
Exemplos:
PS> "abc", "def" -contains "def"
True
PS> "Windows", "PowerShell" -contains "Shell"
False #Not an exact match
# Does the list of computers in $DomainServers include $ThisComputer?
PS> $DomainServers -contains $thisComputer
True
PS> "abc", "def", "ghi" -contains "abc", "def"
False
PS> $a = "abc", "def"
PS> "abc", "def", "ghi" -contains $a
False
PS> $a, "ghi" -contains $a
True
-notcontains
Descrição: operador de contenção. Informa se uma coleção de valores de referência inclui um único valor de teste. Sempre retorna um valor booliano. 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 a igualdade de referência.
Sintaxe:
<Reference-values> -notcontains <Test-value>
Exemplos:
PS> "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> $ApprovedVerbs = Get-Verb | foreach {$_.verb}
PS> $myVerbs = Get-Command -Module MyModule | foreach {$_.verb}
PS> $myVerbs | where {$ApprovedVerbs -notcontains $_}
ForEach
Sort
Tee
Where
-in
Descrição: no operador. Informa se um valor de teste aparece em uma coleção de valores de referência. Sempre retorne como valor booliano. Retorna TRUE somente quando o valor de teste corresponde exatamente a pelo menos um dos valores de referência.
Quando o valor de teste é uma coleção, o operador In usa a igualdade de referência. Ele retorna TRUE somente quando um dos valores de referência é a mesma instância do objeto de valor de teste.
O -in operador foi introduzido no PowerShell 3.0.
Sintaxe:
<Test-value> -in <Reference-values>
Exemplos:
PS> "def" -in "abc", "def"
True
PS> "Shell" -in "Windows", "PowerShell"
False #Not an exact match
PS> "Windows" -in "Windows", "PowerShell"
True #An exact match
PS> "Windows", "PowerShell" -in "Windows", "PowerShell", "ServerManager"
False #Using reference equality
PS> $a = "Windows", "PowerShell"
PS> $a -in $a, "ServerManager"
True #Using reference equality
# Does the list of computers in $DomainServers include $ThisComputer?
PS> $thisComputer -in $domainServers
True
-notin
Descrição: informa se um valor de teste aparece em uma coleção de valores de referência. Sempre retorna um valor booliano. 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 a igualdade de referência. Ele retorna TRUE somente quando um dos valores de referência é a mesma instância do objeto de valor de teste.
O -notin operador foi introduzido no PowerShell 3.0.
Sintaxe:
<Test-value> -notin <Reference-values>
Exemplos:
PS> "def" -notin "abc", "def"
False
PS> "ghi" -notin "abc", "def"
True
PS> "Shell" -notin "Windows", "PowerShell"
True #Not an exact match
PS> "Windows" -notin "Windows", "PowerShell"
False #An exact match
# Find unapproved verbs in the functions in my module
PS> $ApprovedVerbs = Get-Verb | foreach {$_.verb}
PS> $MyVerbs = Get-Command -Module MyModule | foreach {$_.verb}
PS> $MyVerbs | where {$_ -notin $ApprovedVerbs}
ForEach
Sort
Tee
Where
Operador de substituição
O -replace operador substitui todo ou parte de um valor pelo valor especificado usando expressões regulares. Você pode usar o -replace 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' }
A sintaxe do operador é a -replace seguinte, em que o <original> espaço reservado representa os caracteres a serem substituídos e o <substitute> espaço reservado representa os caracteres que os substituirão:
<input> <operator> <original>, <substitute>
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 sem diferenciação de maiúsculas de minúsculas, use -ireplace.
Considere os seguintes exemplos:
PS> "book" -replace "B", "C"
Cook
"book" -ireplace "B", "C"
Cook
"book" -creplace "B", "C"
book
Também é possível usar expressões regulares para substituir dinamicamente o texto usando grupos de captura e substituições. Para obter mais informações, consulte about_Regular_Expressions.
Substituições de ScriptBlock
A partir do PowerShell 6, você pode usar um argumento ScriptBlock para o texto de substituição . O ScriptBlock será executado para cada correspondência encontrada na cadeia de caracteres de entrada .
No ScriptBlock, use a $_ variável automática para se referir ao objeto System.Text.RegularExpressions.Match atual. O objeto Match fornece acesso ao texto de entrada atual que está sendo substituído, bem como outras informações úteis.
Este exemplo substitui cada sequência de três decimais pelo equivalente de caracteres. O ScriptBlock é executado para cada conjunto de três decimais que precisam ser substituídos.
PS> "072101108108111" -replace "\d{3}", {[char][int]$_.Value}
Hello
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.
-is
Sintaxe:
<object> -is <type reference>
Exemplo:
PS> $a = 1
PS> $b = "1"
PS> $a -is [int]
True
PS> $a -is $b.GetType()
False
-isnot
Sintaxe:
<object> -isnot <type reference>
Exemplo:
PS> $a = 1
PS> $b = "1"
PS> $a -isnot $b.GetType()
True
PS> $b -isnot [int]
True