Operador Like do PowerShell e Mais: Aumente seu Jogo de Script

Como muitas outras linguagens de programação, o PowerShell possui vários operadores de comparação. No entanto, ao contrário de outras linguagens, esses operadores de comparação podem parecer um pouco estranhos. Em vez de ==, você tem eq. Em vez de <>, você tem ne. Isso pode ser confuso para iniciantes. Vamos dar uma olhada no operador de comparação like do PowerShell e em outros operadores de comparação neste artigo.

Testando igualdade com os operadores eq e ceq

Para verificar se um objeto é igual a outro objeto no PowerShell, você usa o operador eq. O operador eq compara objetos simples de muitos tipos, como strings, valores booleanos, inteiros e assim por diante. Quando usado, o operador eq retornará um valor booleano True ou False dependendo do resultado.

O operador -eq precisa de dois valores para comparar. Digamos que você atribua uma string a uma variável chamada $string. Você gostaria de comparar o valor dessa variável com o valor da string "PowerShell" para garantir que sejam iguais.

No exemplo a seguir, você pode ver que estamos atribuindo o valor PowerShell à variável $string. Em seguida, usando o operador eq, o exemplo está comparando o valor de $string com a string powershell. Fácil o suficiente, certo? Mas espere, eles não são realmente os mesmos.

PS> $string = "PowerShell"
PS> $string -eq "powershell"
True

Observe que = é um operador de atribuição e NÃO um operador de comparação. Você não pode usar = para comparar um valor com outro no PowerShell.

Testando a Sensibilidade a Maiúsculas e Minúsculas com o Operador ceq

No exemplo acima, observe como o eq retornou um valor booleano True acima, mesmo quando a string não era exatamente a mesma. Esse comportamento ocorre porque o operador eq é insensível a maiúsculas e minúsculas. Para testar a igualdade com sensibilidade a maiúsculas e minúsculas, use o operador ceq. O operador ceq é exatamente o mesmo que o eq, com a exceção de ser sensível a maiúsculas e minúsculas.

Você pode ver um exemplo de uso do ceq no trecho de código a seguir. Agora observe como o PowerShell percebe a diferença com sensibilidade a maiúsculas e minúsculas.

PS> $string -ceq "PowerShell"
True 
PS> $string -ceq "powershell"
False

Testando a Desigualdade com os Operadores ne e cne

Assim como o eq e ceq testam a igualdade, o PowerShell tem um par de operadores que fazem o oposto chamado ne e cne. Assim como seus equivalentes, esses dois operadores realizam a mesma operação, mas de forma oposta.

PS> $string = "PowerShell"
PS> $string -ne "PowerShell"
False
PS> $string -cne "PowerShell"
False
PS> $string -cne "powershell"
True

Testando Itens em uma Coleção

Normalmente, os operadores eq e ceq são usados para valores escalares ou únicos, como strings, inteiros e valores booleanos. Mas esses operadores também podem encontrar instâncias de valores específicos contidos em uma coleção, como um array.

Observe no exemplo abaixo que estamos criando um array com 12 inteiros. Talvez você queira encontrar todas as instâncias nesse array que sejam iguais ao número 9. Sem problemas, use o operador eq contra o array para retornar todas as instâncias do inteiro comparado.

PS> $array =@(1,2,3,4,5,6,7,8,9,9,9,9)
PS> $array -eq 9
9
9
9
9
PS> ($array -eq 9).Count
4

Testando Coleções para Conter Valores

Já que você acabou de aprender a usar o operador eq para encontrar instâncias em arrays, vamos dar um passo adiante e introduzir os operadores de “contenção”. Esses operadores são contains, notcontains, in e notin. Esses operadores retornam um valor booleano True ou False se uma coleção contém uma instância ou não.

Confira o exemplo a seguir. Neste exemplo, estamos criando um array com nove inteiros. Se você deseja uma resposta simples de Sim/Não para saber se esse array contém um determinado inteiro, você pode obter isso usando contains ou notcontains.

PS> $array = @(2,4,5,6,8,8,9,9,9)
PS> $array -contains 9
True
PS> $array -notcontains 9
False
PS> $array -contains 5

Da mesma forma, você tem os operadores in e notin. Esses operadores são praticamente idênticos a contains e notcontains com uma exceção: o valor a ser comparado está à esquerda em vez da direita.

$array = @(2,4,5,6,8,8,9,9,9)
9 -in $array
True
9 -notin $array
False

Testando “Maior que” com os operadores gt e ge

O que acontece se você precisar testar se um número (um inteiro) é maior que outro número ou talvez maior ou igual a outro número? Você usaria os operadores gt e ge. Esses operadores comparam inteiros.

Assim como os outros operadores, esses operadores retornam valores booleanos Verdadeiro ou Falso dependendo se um inteiro é maior que outro. Ambos os operadores testam se o inteiro à esquerda é maior que ou maior ou igual ao inteiro à direita.

No exemplo abaixo, você pode ver como cada um desses operadores se comporta.

PS> 7 -gt 5
True
PS> 7 -gt 7
False
PS> 7 -ge 7
True

Semelhante ao operador eq que permite encontrar instâncias em coleções, você pode fazer o mesmo com os operadores ge e gt também. O PowerShell percorre cada item em uma coleção e compara cada valor com o que você forneceu. Você pode ver um ótimo exemplo disso abaixo.

PS> $array =@(1,2,3,4,5,6,7,8,9,9,9,9)
PS> $array -gt 5
6
7
8
9
9
9
9
PS> $array -ge 5
5
6
7
8
9
9
9
9

Testando “menor que” com os operadores lt e le

Semelhante aos operadores gt e ge, os operadores lt e le executam a mesma função, mas de forma oposta. Os operadores lt e le comparam dois valores, testando se o inteiro do lado esquerdo é menor que ou menor ou igual ao inteiro do lado direito.

Você pode ver no exemplo abaixo que a mesma funcionalidade de comparar cada valor em uma coleção se aplica exatamente da mesma forma que gt e ge.

PS> $array =@(1,2,3,4,5,6,7,8,9,10)
PS> $array -lt 5
1
2
3
4
PS> $array -le 5 
1
2
3
4
5

Correspondência com base em curingas com o operador Like do PowerShell

Até agora, você aprendeu como realizar correspondências 1:1. Todos os operadores usados até agora compararam um valor inteiro com outro, mas o PowerShell tem outro truque na manga. Você também pode comparar valores com base em caracteres coringa ou asteriscos.

Vamos supor que você só conhece alguns caracteres de uma string. Você não pode usar o eq porque o eq exige que você conheça a string inteira. Usando o operador like do PowerShell, você não precisa conhecer a string inteira. Para testar se um valor é parecido com outro, você pode substituir a parte que não conhece por um caractere coringa.

Assim como outros operadores, essa mesma funcionalidade pode ser aplicada a coleções também.

Você pode ver um exemplo de operador like do PowerShell e seu equivalente com diferenciação de maiúsculas e minúsculas, clike, abaixo.

PS> $string = "PowerShell"
PS> $string -like "*Shell"
True
PS> $array = @("PowerShell","Microsoft")
PS> $array -like "*Shell"
PowerShell
PS> $array -clike "*Shell"
PowerShell

O operador -notlike retorna booleano True se nenhuma correspondência for encontrada e False se houver uma correspondência. No caso de usar contra uma coleção, ele retornará todos os outros valores que não correspondem ao padrão fornecido do lado direito do operador -notlike. Para adicionar sensibilidade a maiúsculas e minúsculas ao padrão, use o operador -cnotlike.

$string = "PowerShell" 
$string -notlike "*Shell"
False
$array = @("PowerShell","Microsoft")
$array -notlike "*Shell"
Microsoft
$array -cnotlike "*shell"
PowerShell
Microsoft

Correspondência com base em expressões regulares.

O operador like do PowerShell e seus similares são úteis, mas assim que você começa a precisar de correspondências mais complexas, você pode mergulhar no mundo sombrio e profundo das expressões regulares (regex). Usando os operadores match e notmatch, você pode fazer correspondências extremamente complexas de strings com regex.

Similarmente ao operador like do PowerShell, match e seu oposto, notmatch, comparam duas strings e retornam um valor booleano True ou False. Da mesma forma que os outros operadores, esse comportamento também pode ser aplicado a uma coleção, como demonstrado no exemplo abaixo.

PS> $string = "PowerShell"
PS> $string -match "ow"
True 

PS> $array = @("PowerShell","Microsoft")
PS> $array -match "ow"
PowerShell

PS> $string = "PowerShell"
PS> $string -cmatch "po"
False
PS> $string -cmatch "Po"
True

PS> $array = @("PowerShell","Microsoft")
PS> $array -cmatch "Po"
PowerShell

Resumo

Neste artigo, você aprendeu sobre o operador like do PowerShell e muitos outros, e como usar cada operador para valores únicos e coleções. Você viu como a saída difere com base no operador e se é escalar ou uma coleção.

Além disso, você também viu operadores com sensibilidade a maiúsculas e minúsculas, operadores de correspondência que correspondem com base em expressões regulares ou wildcards, e operadores de contenção para testar se o objeto contém um valor específico ou se um valor existe em um objeto específico.

PowerShell Like

Source:
https://adamtheautomator.com/powershell-like/