TEMA
    about_Comparison_Operators

DESCRIPCIÓN BREVE
    Describe los operadores que comparan valores en Windows PowerShell.

DESCRIPCIÓN DETALLADA
    Los operadores de comparación permiten especificar las 
    condiciones para comparar valores y buscar valores que coinciden 
    con patrones especificados. Para usar un operador de comparación, se 
    especifican los valores que se desea comparar, junto con un operador 
    que los separa.
        

    De forma predeterminada, los operadores de comparación no 
    distinguen entre mayúsculas y minúsculas. Para que un operador de 
    comparación distinga entre mayúsculas y minúsculas, su nombre debe ir 
    precedido de un "c".
    Por ejemplo, la versión de "-eq" que distingue entre mayúsculas y 
    minúsculas es "-ceq". Para indicar explícitamente que no se 
    distinga entre mayúsculas y minúsculas, el operador debe ir 
    precedido de "i". Por ejemplo, la versión de "-eq" que 
    explícitamente no distingue entre mayúsculas y minúsculas es "ieq".


    Todos los operadores de comparación, excepto los de contención 
    (-contains, -notcontains) y los de tipo (-is, -isnot) devuelven 
    un valor de tipo boolean cuando la entrada al operador (el valor 
    que figura a la izquierda del operador) es un valor único (un 
    escalar). Cuando la entrada es una colección de valores, los 
    operadores de contención y de tipo devuelven todos los valores 
    coincidentes. Si no hay ninguna coincidencia en una colección, estos 
    operadores no devuelven nada. Los operadores de contención y los 
    operadores de tipo siempre devuelven un valor de tipo boolean.


    Windows PowerShell admite los siguientes operadores de comparación.


    -eq
      Descripción: igual a. Incluye un valor idéntico.
      Ejemplo:


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


    -ne
      Descripción: distinto de. Incluye un valor diferente.
      Ejemplo:


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


    -gt
      Descripción: mayor que.
      Ejemplo:


          C:\PS> 8 -gt 6
          True



    -ge
      Descripción: mayor o igual que.
      Ejemplo:


          C:\PS> 8 -ge 8
          True         


    -lt
      Descripción: menor que.
      Ejemplo:


          C:\PS> 8 -lt 6
          False


    -le
      Descripción: menor o igual que.
      Ejemplo:


          C:\PS> 6 -le 8
          True

 
    -like
      Descripción: busca coincidencias utilizando el carácter comodín (*).
      Ejemplo:


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


    -notlike
      Descripción: busca valores que no coinciden mediante el carácter comodín (*).
      Ejemplo:


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

    -match 
      Descripción: busca coincidencias de una cadena mediante expresiones 
                   regulares. Cuando la entrada es escalar, rellena la variable 
                   automática $Matches. 
      Ejemplo:

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

          C:\PS> $matches 
          Nombre Valor 
          ---- ----- 
          0  dom
 
 
    -notmatch
      Descripción: busca valores que no coinciden con una cadena. Utiliza 
                   expresiones regulares.
                   Cuando la entrada es escalar, rellena la variable 
                   automática $Matches. 
      Ejemplo:


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

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

 
    -contains
      Descripción: operador de contención. Incluye un valor idéntico 
      que no forma parte de un valor. Siempre devuelve un valor de 
      tipo boolean.
      Ejemplo:


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


    -notcontains
      Descripción: operador de contención. No incluye un valor 
      idéntico. Siempre devuelve valores de tipo boolean.
      Ejemplo:


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

    -replace
      Descripción: operador de reemplazo. Cambia los elementos 
      especificados de un valor.
      Ejemplo:


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

  Operadores de igualdad
      Los operadores de igualdad (-eq, -ne) devuelven el valor TRUE o las 
      coincidencias encontradas cuando uno o más de los valores de entrada 
      son idénticos al patrón especificado. El patrón completo debe 
      coincidir con un valor completo.


      En los ejemplos siguientes se muestra el efecto del operador igual a:


          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 contención
      Los operadores de contención (-contains y -notcontains) son 
      similares a los operadores de igualdad. Sin embargo, los 
      operadores de contención siempre devuelven un valor de tipo 
      boolean, aunque la entrada sea una colección. 


      Además, a diferencia de los operadores de igualdad, los 
      operadores de contención devuelven un valor tan pronto como 
      detectan la primera coincidencia. Los operadores de igualdad 
      evalúan toda la entrada y, a continuación, devuelven todas las 
      coincidencias de la colección.
      En los ejemplos siguientes se muestra el efecto del 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> "verdadero", "azul", "seis" -contains "verdadero"
          True
 

      En el ejemplo siguiente se muestran las diferencias entre los 
      operadores de contención y el operador igual a. Los operadores 
      de contención devuelven el valor TRUE cuando se produce la primera 
      coincidencia.
 

          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
 
      
      En una colección muy grande, el operador -contains devuelve 
      resultados antes que el operador igual a.


  Operadores de coincidencia
      Los operadores de coincidencia (-match y -notmatch) buscan 
      elementos que coinciden o no coinciden con un patrón 
      especificado mediante expresiones regulares. 

      La sintaxis es la siguiente:

          <string[]> -match <expresión-regular>
          <string[]> -notmatch <expresión-regular>


      En los ejemplos siguientes se muestran algunos usos del 
      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 "^Server\d\d"
          Server01
          Server02

         
      Los operadores de coincidencia buscan solamente en cadenas. No 
      pueden buscar en matrices de enteros ni en otros objetos. 

      Los operadores -match y -notmatch rellenan la variable 
      automática $Matches cuando la entrada (el argumento de la 
      izquierda) al operador es un único objeto escalar. Cuando la 
      entrada es escalar, los operadores -match y -notmatch devuelven 
      un valor de tipo boolean y establecen el valor de la variable 
      automática $Matches en los componentes coincidentes del argumento.

      Si la entrada es una colección, los operadores -match y 
      -notmatch devuelven los miembros coincidentes de esa colección, 
      pero el operador no rellena la variable $Matches.

      Por ejemplo, el comando siguiente envía una colección de 
      cadenas al operador -match. El operador -match devuelve los 
      elementos que coinciden de la colección. No rellena la variable 
      automática $Matches.

          C:\PS> "Domingo", "Lunes", "Martes" -match "dom"
          Domingo

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


      En contraste, el comando siguiente envía una sola cadena al 
      operador de coincidencia. El operador -match devuelve un valor 
      de tipo boolean y rellena la variable automática $Matches.

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

          C:\PS> $matches

          Nombre                         Valor
          ----                           -----
          0                              Dom


      El operador -notmatch rellena la variable automática $Matches 
      cuando la entrada es escalar y el resultado es False, es decir, 
      cuando detecta una coincidencia.


          C:\PS> "Domingo" -notmatch "lluvia"
          True

          C:\PS> $matches
          C:\PS>
          
          C:\PS> "Domingo" -notmatch "ngo"
          False

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

          Nombre                         Valor
          ----                           -----
          0                              ngo

        
  Operador de sustitución
      El operador -replace reemplaza la totalidad o parte de un valor 
      con el valor especificado mediante expresiones regulares. Puede 
      utilizar el operador -replace para muchas tareas administrativas, 
      tales como cambiar el nombre de los archivos. Por ejemplo, el 
      comando siguiente cambia las extensiones de nombre de archivo 
      de todos los archivos .gif por .jpg:
 

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

 
      La sintaxis del operador -replace es la siguiente, donde el 
      marcador de posición <original> representa los caracteres que 
      se van a reemplazar y el marcador de posición <sustituto> 
      representa los caracteres que los 
      reemplazarán:


          <entrada> <operador> <original>, <sustituto> 


      De forma predeterminada, el operador -replace no distingue entre 
      mayúsculas y minúsculas. Para que sí las distinga, se utiliza -
      creplace. Para que explícitamente no efectúe la distinción entre 
      mayúsculas y minúsculas, se utiliza ireplace. Observe los ejemplos 
      siguientes:


          C:\PS> "libro" -replace "B", "T"
          liTro
          C:\PS> "libro" -ireplace "B", "T" 
          liTro
          C:\PS> "libro" -creplace "B", "T"
          libro
 

  Operadores bit a bit
      Windows PowerShell admite los operadores bit a bit estándar, 
      incluidos AND bit a bit (-band) y los operadores OR bit a bit 
      incluyentes y excluyentes (-bor y -bxor). A partir de Windows 
      PowerShell 2.0, todos los operadores bit a bit funcionan con 
      enteros de 64 bits.


      Windows PowerShell admite los siguientes operadores bit a bit.


      Operador  Descripción                 Ejemplo  
      --------  ----------------------      -------------------
      -band     AND bit a bit               C:\PS> 10 -band 3
                                            2
 
      -bor      OR bit a bit (incluyente)   C:\PS> 10 -bor 3
                                            11    

      -bxor     OR bit a bit (excluyente)   C:\PS> 10 -bxor 3
                                            9
 
      Los operadores bit a bit operan con el formato binario de un 
      valor. Por ejemplo, la estructura de bits correspondiente al 
      número 10 es 00001010 (en formato de 1 byte) y la del número 3 
      es 00000011. Cuando se usa un operador bit a bit para comparar 
      10 con 3, se compararán los bits individuales de cada byte.
 

      En una operación con AND bit a bit, el bit resultante se 
      establece en 1 únicamente si los dos bits de entrada son 1.


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

 
      En una operación de OR bit a bit (incluyente), el bit resultante se 
      establece en 1 cuando uno de los dos bits de entrada o ambos son 1. El bit 
      resultante se establece en 0 solamente si ambos bits de entrada se 
      establecen en 0.


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


      En una operación OR bit a bit (excluyente), el bit resultante 
      se establece en 1 solamente cuando uno de los bits de entrada es 1.


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

VEA TAMBIÉN
    about_Operators
    about_Regular_Expressions
    about_Wildcards
    Compare-Object




Tabla de contenido