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