Compartilhar via


about_Comparison_Operators

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