about_Comparison_Operators
Se aplica a: Windows PowerShell 2.0, Windows PowerShell 3.0, Windows PowerShell 4.0
Insertar la introducción aquí.
TEMA
about_Comparison_Operators
DESCRIPCIÓN BREVE
Describe los operadores que comparan valores en Windows PowerShell®.
DESCRIPCIÓN LARGA
Los operadores de comparación le permiten especificar condiciones para comparar valores y buscar valores que coincidan con los modelos especificados. Para usar un operador de comparación, especifique los valores que desea comparar junto con un operador que separe estos valores.
Windows PowerShell incluye los siguientes operadores de comparación:
-eq
-ne
-gt
-ge
-lt
-le
-Like
-NotLike
-Match
-NotMatch
-Contains
-NotContains
-In
-NotIn
-Replace
De forma predeterminada, todos los operadores de comparación no distinguen mayúsculas de minúsculas. Para hacer que un operador de comparación distinga mayúsculas de minúsculas, anteponga una "c" al nombre del operador. Por ejemplo, la versión de "-eq" que distingue mayúsculas de minúsculas es "-ceq". Para indicar explícitamente que no distingue mayúsculas de minúsculas, anteponga una "i" al operador. Por ejemplo, la versión de "-eq" que no distingue explícitamente mayúsculas de minúsculas es "-ieq".
Cuando la entrada de un operador es un valor escalar, los operadores de comparación devuelven un valor booleano. Cuando la entrada es una colección de valores, los operadores de comparación devuelven todos los valores coincidentes. Si no hay ninguna coincidencia en una colección, los operadores de comparación no devuelven nada.
Las excepciones son los operadores de inclusión (-Contains, -NotContains), los operadores In (-In, -NotIn) y los operadores de tipo (-Is, -IsNot), que siempre devuelven un valor booleano.
Windows PowerShell admite los siguientes operadores de comparación.
-eq
Descripción: es igual a. Incluye un valor idéntico.
Ejemplo:
PS C:\> "abc" -eq "abc"
True
PS C:\> "abc" -eq "abc", "def"
False
PS C:\> "abc", "def" -eq "abc"
abc
-ne
Descripción: no es igual a. Incluye un valor diferente.
Ejemplo:
PS C:\> "abc" -ne "def"
True
PS C:\> "abc" -ne "abc"
False
PS C:\> "abc" -ne "abc", "def"
True
PS C:\> "abc", "def" -ne "abc"
def
-gt
Descripción: es mayor que.
Ejemplo:
PS C:\> 8 -gt 6
True
PS C:\> 7, 8, 9 -gt 8
9
-ge
Descripción: es mayor o igual que.
Ejemplo:
PS C:\> 8 -ge 8
True
PS C:\> 7, 8, 9 -ge 8
8
9
-lt
Descripción: es menor que.
Ejemplo:
PS C:\> 8 -lt 6
False
PS C:\> 7, 8, 9 -lt 8
7
-le
Descripción: es menor o igual que.
Ejemplo:
PS C:\> 6 -le 8
True
PS C:\> 7, 8, 9 -le 8
7
8
-Like
Descripción: busca usando el carácter comodín (*).
Ejemplo:
PS C:\> "Windows PowerShell" -like "*shell"
True
PS C:\> "Windows PowerShell", "Server" -like "*shell"
Windows PowerShell
-NotLike
Descripción: no busca usando el carácter comodín (*).
Ejemplo:
PS C:\> "Windows PowerShell" -NotLike "*shell"
False
PS C:\> "Windows PowerShell", "Server" -NotLike "*shell"
Server
-Match
Descripción: busca una cadena usando expresiones regulares. Cuando la entrada es escalar, rellena la variable automática $Matches.
Ejemplo:
PS C:\> "Sunday" -Match "sun"
True
PS C:\> $matches
Name Value
---- -----
0 Sun
PS C:\> "Sunday", "Monday" -Match "sun"
Sunday
-NotMatch
Descripción: no busca una cadena. Usa expresiones regulares. Cuando la entrada es escalar, rellena la variable automática $Matches.
Ejemplo:
PS C:\> "Sunday" -NotMatch "sun"
False
PS C:\> $matches
Name Value
---- -----
0 sun
PS C:\> "Sunday", "Monday" -NotMatch "sun"
Monday
-Contains
Descripción: operador de inclusión. Indica si una colección de valores de referencia incluye un valor de prueba única. Siempre devuelve un valor booleano. Devuelve TRUE solo si el valor de prueba coincide exactamente con al menos uno de los valores de referencia.
Cuando el valor de prueba es una colección, el operador Contains usa la igualdad de referencia. Devuelve TRUE solo si uno de los valores de referencia es la misma instancia del objeto de valor de prueba.
Sintaxis:
<Reference-values> -Contains <Test-value>
Ejemplos:
PS C:\> "abc", "def" -Contains "def"
True
PS C:\> "Windows", "PowerShell" -Contains "Shell"
False #Not an exact match
# Does the list of computers in $domainServers
# include $thisComputer?
# -------------------------------------------
PS C:\> $domainServers -Contains $thisComputer
True
PS C:\> "abc", "def", "ghi" -Contains "abc", "def"
False
PS C:\> $a = "abc", "def"
PS C:\> "abc", "def", "ghi" -Contains $a
False
PS C:\> $a, "ghi" -Contains $a
True
-NotContains
Descripción: operador de inclusión. Indica si una colección de valores de referencia incluye un valor de prueba única. Siempre devuelve un valor booleano. Devuelve TRUE si el valor de prueba no es una coincidencia exacta de al menos uno de los valores de referencia.
Si el valor de prueba es una colección, el operador NotContains usa la igualdad de referencia.
Sintaxis:
<Reference-values> -NotContains <Test-value>
Ejemplos:
PS C:\> "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 C:\> $ApprovedVerbs = Get-Verb | foreach {$_.verb}
PS C:\> $myVerbs = Get-Command -Module MyModule | foreach {$_.verb}
PS C:\> $myVerbs | where {$ApprovedVerbs -NotContains $_}
ForEach
Sort
Tee
Where
-In
Descripción: operador In. Indica si un valor de prueba aparece en una colección de valores de referencia. Siempre devuelve un valor booleano. Devuelve TRUE solo si el valor de prueba coincide exactamente con al menos uno de los valores de referencia.
Si el valor de prueba es una colección, el operador In usa la igualdad de referencia. Devuelve TRUE solo si uno de los valores de referencia es la misma instancia del objeto de valor de prueba.
El operador In se introdujo en Windows PowerShell 3.0.
Sintaxis:
<Test-value> -in <Reference-values>
Ejemplos:
PS C:\> "def" -in "abc", "def"
True
PS C:\> "Shell" -in "Windows", "PowerShell"
False #Not an exact match
PS C:\> "Windows" -in "Windows", "PowerShell"
True #An exact match
PS C:\> "Windows", "PowerShell" -in "Windows", "PowerShell", "ServerManager"
False #Using reference equality
PS C:\> $a = "Windows", "PowerShell"
PS C:\> $a -in $a, "ServerManager"
True #Using reference equality
# Does the list of computers in $domainServers
# include $thisComputer?
# -------------------------------------------
PS C:\> $thisComputer -in $domainServers
True
-NotIn
Descripción: operador NotIn. Indica si un valor de prueba aparece en una colección de valores de referencia. Siempre devuelve un valor booleano. Devuelve verdadero si el valor de prueba no es una coincidencia exacta para al menos uno de los valores de referencia.
Si el valor de prueba es una colección, el operador In usa la igualdad de referencia. Devuelve TRUE solo si uno de los valores de referencia es la misma instancia del objeto de valor de prueba.
El operador NotIn se introdujo en Windows PowerShell 3.0.
Sintaxis:
<Test-value> -NotIn <Reference-values>
Ejemplos:
PS C:\> "def" -NotIn "abc", "def"
False
PS C:\> "ghi" -NotIn "abc", "def"
True
PS C:\> "Shell" -NotIn "Windows", "PowerShell"
True #Not an exact match
PS C:\> "Windows" -NotIn "Windows", "PowerShell"
False #An exact match
# Find unapproved verbs in the functions in my module
# -------------------------------------------
PS C:\> $ApprovedVerbs = Get-Verb | foreach {$_.verb}
PS C:\> $myVerbs = Get-Command -Module MyModule | foreach {$_.verb}
PS C:\> $myVerbs | where {$_ -NotIn $ApprovedVerbs}
ForEach
Sort
Tee
Where
-Replace
Descripción: operador de sustitución. Cambia los elementos especificados de un valor.
Ejemplo:
PS C:\> "Get-Process" -Replace "Get", "Stop"
Stop-Process
# Change all .GIF file name extension to .JPG
PS C:\> dir *.gif | foreach {$_ -Replace ".gif", ".jpg"}
OPERADORES DE IGUALDAD
Los operadores de igualdad (-eq, ne-) devuelven un valor TRUE o coincidencias si uno o varios valores de entrada son idénticos al patrón especificado. Todo el patrón debe coincidir con un valor completo.
C:PS> 2 -eq 2
True
C:PS> 2 -eq 3
False
C:PS> 1,2,3 -eq 2
2
C:PS> "PowerShell" -eq "Shell"
False
C:PS> "Windows", "PowerShell" -eq "Shell"
C:PS>
PS C:\> "abc", "def", "123" -eq "def"
def
PS C:\> "abc", "def", "123" -ne "def"
abc
123
OPERADORES DE INCLUSIÓN
Los operadores de inclusión (-Contains y -NotContains) son parecidos a los operadores de igualdad. Sin embargo, los operadores de inclusión siempre devuelven un valor booleano, incluso cuando la entrada es una colección.
Además, a diferencia de los operadores de igualdad, los operadores de inclusión devuelven un valor en cuanto detectan la primera coincidencia. Los operadores de igualdad evalúan todas las entradas y, a continuación, devuelven todas las coincidencias de la colección. Los ejemplos siguientes muestran 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
PS C:\> "abc", "def", "123" -contains "def"
True
PS C:\> "true", "blue", "six" -contains "true"
True
En el ejemplo siguiente se muestra la manera en que los operadores de inclusión difieren del operador es igual a. Los operadores de inclusión devuelven un valor TRUE en la primera coincidencia.
PS C:\> 1,2,3,4,5,4,3,2,1 -eq 2
2
2
PS C:\> 1,2,3,4,5,4,3,2,1 -contains 2
True
En una colección muy grande, el operador -Contains devuelve resultados más rápido que el operador es igual a.
Operadores de coincidencia
Los operadores de coincidencia (-Match y -NotMatch) buscan los elementos que coinciden o no coinciden con un patrón especificado mediante expresiones regulares.
La sintaxis es la siguiente:
<string[]> -Match <regular-expression>
<string[]> -NotMatch <regular-expression>
Los ejemplos siguientes muestran algunos usos del operador -Match:
PS C:\> "Windows", "PowerShell" -Match ".shell"
PowerShell
PS C:\> (Get-Command Get-Member -Syntax) -Match "-view"
True
PS C:\> (Get-Command Get-Member -Syntax) -NotMatch "-path"
True
PS C:\> (Get-Content Servers.txt) -Match "^Server\d\d"
Server01
Server02
Los operadores de coincidencia solo buscan en cadenas. No pueden buscar en matrices de enteros u otros objetos.
Los operadores -Match y -NotMatch rellenan la variable automática $Matches cuando la entrada (el argumento de la izquierda) del operador es un solo objeto escalar. Cuando la entrada es escalar, los operadores -Match y -NotMatch devuelven un valor booleano 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 correspondientes 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 de la colección que coinciden. No rellena la variable automática $Matches.
PS C:\> "Sunday", "Monday", "Tuesday" -Match "sun"
Sunday
PS C:\> $matches
PS C:\>
En cambio, el comando siguiente envía una sola cadena al operador -Match. El operador -Match devuelve un valor booleano y rellena la variable automática $Matches.
PS C:\> "Sunday" -Match "sun"
True
PS C:\> $matches
Name Value
---- -----
0 Sun
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.
PS C:\> "Sunday" -NotMatch "rain"
True
PS C:\> $matches
PS C:\>
PS C:\> "Sunday" -NotMatch "day"
False
PS C:\> $matches
PS C:\>
Name Value
---- -----
0 day
OPERADOR DE SUSTITUCIÓN
El operador -Replace reemplaza la totalidad o una parte de un valor con el valor especificado mediante expresiones regulares. Puede usar el operador -Replace para muchas tareas administrativas, como cambiar el nombre de los archivos. Por ejemplo, el comando siguiente cambia las extensiones de nombre de archivo de todos los archivos .gif a .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 van a ser reemplazados y el marcador de posición <substitute> representa los caracteres que los reemplazarán:
<input> <operator> <original>, <substitute>
De forma predeterminada, el operador -Replace no distingue mayúsculas de minúsculas. Para que sea distinga mayúsculas de minúsculas, use -cReplace. Para que no distinga explícitamente mayúsculas de minúsculas, use -iReplace. Tenga en cuenta los ejemplos siguientes:
PS C:\> "book" -Replace "B", "C"
Cook
PS C:\> "book" -iReplace "B", "C"
Cook
PS C:\> "book" -cReplace "B", "C"
book
PS C:\> '<command:parameter required="false" variableLength="true" globbing="false"'`
| foreach {$_ -replace 'globbing="false"', 'globbing="true"'}
<command:parameter required="false" variableLength="true" globbing="true"
Operadores bit a bit
Windows PowerShell admite los operadores bit a bit estándar, incluidos bitwise-AND (-bAnd), los operadores inclusivos y exclusivos bitwise-OR (-bOr y -bXor) y bitwise-NOT (-bNot).
A partir de Windows PowerShell 2.0, todos los operadores bit a bit funcionan con números enteros de 64 bits.
A partir de Windows PowerShell 3.0, se introducen -shr (desplazamiento a la derecha) y -shl (desplazamiento a la izquierda) para admitir operaciones aritméticas bit a bit en Windows PowerShell.
Windows PowerShell admite los siguientes operadores bit a bit.
Operator Description Example
-------- ---------------------- -------------------
-bAnd Bitwise AND PS C:\> 10 -band 3
2
-bOr Bitwise OR (inclusive) PS C:\> 10 -bor 3
11
-bXor Bitwise OR (exclusive) PS C:\> 10 -bxor 3
9
-bNot Bitwise NOT PS C:\> -bNot 10
-11
-shl Shift-left PS C:\> 100 -shl 2
400
-shr Shift-right PS C:\> 100 -shr 1
50
Los operadores bit a bit actúan sobre el formato binario de un valor. Por ejemplo, la estructura de bits del número 10 es 00001010 (basado en 1 byte) y la estructura de bits del número 3 es 00000011. Cuando se usa un operador bit a bit para comparar 10 y 3, se comparan los bits individuales de cada byte.
En una operación AND bit a bit, el bit resultante se establece en 1 solo cuando ambos bits de entrada son 1.
1010 (10)
0011 ( 3)
-------------- bAND
0010 ( 2)
En una operación OR bit a bit (inclusiva), el bit resultante se establece en 1 cuando uno de los bits de entrada o ambos son 1. El bit resultante se establece en 0 solo cuando ambos bits de entrada se establecen en 0.
1010 (10)
0011 ( 3)
-------------- bOR (inclusive)
1011 (11)
En una operación OR bit a bit (exclusiva), el bit resultante se establece en 1 solo si un bit de entrada es 1.
1010 (10)
0011 ( 3)
-------------- bXOR (exclusive)
1001 ( 9)
El operador NOT bit a bit es un operador unario que genera el complemento binario del valor. Un bit 1 se establece en 0 y un bit 0 se establece en 1.
Por ejemplo, el complemento binario de 0 es -1, el mayor número entero sin signo (0xffffffff), y el complemento binario de -1 es 0.
PS C:\> -bNOT 10
-11
0000 0000 0000 1010 (10)
------------------------- bNOT
1111 1111 1111 0101 (-11, xfffffff5)
En una operación de desplazamiento a la izquierda bit a bit, todos los bits se mueven "n" lugares a la izquierda, donde "n" es el valor del operando derecho. Se inserta un cero en el lugar de los unos.
Cuando el operando izquierdo es un valor entero (32 bits), los 5 bits inferiores del operando derecho determinan cuántos bits del operando izquierdo se desplazan.
Cuando el operando izquierdo es un valor largo (64 bits), los 6 bits inferiores del operando derecho determinan cuántos bits del operando izquierdo se desplazan.
PS C:\> 21 -shl 1
42
00010101 (21)
00101010 (42)
PS C:\> 21 -shl 2
84
00010101 (21)
00101010 (42)
01010100 (84)
En una operación de desplazamiento a la derecha bit a bit, todos los bits se mueven "n" lugares a la derecha, donde "n" está especificado por el operando derecho. El operador de desplazamiento a la derecha (-shr) inserta un cero en el extremo izquierdo cuando cambia un valor positivo o sin signo a la derecha.
Cuando el operando izquierdo es un valor entero (32 bits), los 5 bits inferiores del operando derecho determinan cuántos bits del operando izquierdo se desplazan.
Cuando el operando izquierdo es un valor largo (64 bits), los 6 bits inferiores del operando derecho determinan cuántos bits del operando izquierdo se desplazan.
PS C:\> 21 -shr 1
10
00010101 (21)
00001010 (10)
PS C:\> 21 -shr 2
5
00010101 (21)
00001010 (10)
00000101 ( 5)
VEA TAMBIÉN
about_Operators
about_Regular_Expressions
about_Wildcards
Compare-Object
Foreach-Object
Where-Object