acerca_de_Operadores_de_Comparación

Descripción breve

Los operadores de comparación de PowerShell pueden comparar dos valores o filtrar elementos de una colección con un valor de entrada.

Descripción larga

Los operadores de comparación permiten comparar valores o buscar valores que coincidan con patrones especificados. PowerShell incluye los siguientes operadores de comparación:

Igualdad

-eq, -ieq, -ceq : es igual a
-ne, -ine, -cne, no son iguales
-gt, -igt, -cgt: mayor que
-ge, -ige, -cge: mayor o igual que
-lt, -ilt, -clt: menor que
-le, -ile, -cle : menor o igual que

coincidente con

-like, -ilike, -clike: la cadena coincide con el patrón de caracteres comodín
-notlike, -inotlike, -cnotlike: la cadena no coincide con el patrón de caracteres comodín
-match, -imatch, -cmatch: la cadena coincide con el patrón regex
-notmatch, -inotmatch, -cnotmatch: la cadena no coincide con el patrón regex

Sustitución

-replace, , -ireplace-creplace : busca y reemplaza cadenas que coinciden con un patrón regex.

Contención

-contains, -icontains, -ccontains : la colección contiene un valor
-notcontains, -inotcontains, -cnotcontains: la colección no contiene un valor
-in, -iin, -cin: el valor está en una colección
-notin, -inotin, -cnotin: el valor no está en un conjunto

Tipo

-is: ambos objetos son del mismo tipo
-isnot: los objetos no son del mismo tipo

Características comunes

Las comparaciones de cadenas no distinguen entre mayúsculas y minúsculas, a menos que se utilice un operador explícitamente sensible a mayúsculas y minúsculas. Para que un operador de comparación distingue mayúsculas de minúsculas, agregue un c después del -. Por ejemplo, -ceq es la versión sensible a mayúsculas y minúsculas de -eq. Para que la distinción entre mayúsculas y minúsculas sea explícita, agregue un i después de -. Por ejemplo, -ieq es la versión explícita que no distingue entre mayúsculas y minúsculas de -eq.

Las comparaciones de cadenas utilizan la InvariantCulture tanto para comparaciones que distinguen entre mayúsculas y minúsculas como para las que no lo hacen. Las comparaciones están entre puntos de código unicode y no usan el orden de intercalación específico de la cultura. Los resultados son los mismos independientemente de la referencia cultural actual.

Cuando el valor izquierdo de la expresión de comparación es un valor escalar de , el operador devuelve un valor booleano de . Cuando el valor izquierdo de la expresión es una colección, el operador devuelve los elementos de la colección que coinciden con el valor derecho de la expresión. Los valores de la derecha siempre se tratan como instancias únicas (singleton), incluso cuando son colecciones. Los operadores de comparación no pueden comparar de forma eficaz colecciones con colecciones.

Si no hay coincidencias en la colección, los operadores de comparación devuelven una matriz vacía. Por ejemplo:

$a = (1, 2) -eq 3
$a.GetType().Name
$a.Count

Object[]
0

Hay algunas excepciones:

Los operadores de contención y tipo siempre devuelven un valor booleano de
El operador -replace devuelve el resultado de la sustitución
Los operadores -match y -notmatch también rellenan la variable automática $Matches a menos que el lado izquierdo de la expresión sea una colección.

Operadores de igualdad

-eq y -ne

Cuando el lado izquierdo es escalar, -eq devuelve True si el lado derecho es equivalente; de lo contrario, -eq devuelve False. -ne hace lo contrario; devuelve False cuando ambos lados son equivalentes; De lo contrario, -ne devuelve True.

Ejemplo:

2 -eq 2                 # Output: True
2 -eq 3                 # Output: False
'abc' -eq 'abc'         # Output: True
'abc' -eq 'abc', 'def'  # Output: False
'abc' -ne 'def'         # Output: True
'abc' -ne 'abc'         # Output: False
'abc' -ne 'abc', 'def'  # Output: True

Cuando el lado izquierdo es una colección, -eq devuelve los miembros que coinciden con el lado derecho, mientras que -ne los excluye.

Ejemplo:

1,2,3 -eq 2             # Output: 2
'abc', 'def' -eq 'abc'  # Output: abc
'abc', 'def' -ne 'abc'  # Output: def

Estos operadores procesan todos los elementos de la colección. Ejemplo:

'zzz', 'def', 'zzz' -eq 'zzz'

zzz
zzz

El operador de igualdad puede comparar objetos de diferentes tipos. Es importante comprender que el valor del lado derecho de la comparación se puede convertir al tipo de valor del lado izquierdo para compararlos.

Por ejemplo, la cadena '1.0' se convierte en un entero que se va a comparar con el valor 1. En este ejemplo se devuelve True.

PS> 1 -eq '1.0'
True

En este ejemplo, el valor 1 se convierte en una cadena que se va a comparar con la cadena '1.0'. En este ejemplo se devuelve False.

PS> '1.0' -eq 1
False

Los operadores de igualdad aceptan cualquier par de objetos, no solo un escalar o una colección. Pero no se garantiza que el resultado de la comparación sea significativo para el usuario final. En el ejemplo siguiente se muestra el problema.

class MyFileInfoSet {
    [string]$File
    [int64]$Size
}
$a = [MyFileInfoSet]@{File = 'C:\Windows\explorer.exe'; Size = 4651032}
$b = [MyFileInfoSet]@{File = 'C:\Windows\explorer.exe'; Size = 4651032}
$a -eq $b

False

En este ejemplo, creamos dos objetos con propiedades idénticas. Sin embargo, el resultado de la prueba de igualdad es False porque son objetos diferentes. Para crear clases comparables, debe implementar System.IEquatable<T> en la clase. En el ejemplo siguiente se muestra la implementación parcial de una clase MyFileInfoSet que implementa System.IEquatableT y tiene dos propiedades, File y Size. El método Equals() devuelve True si las propiedades File y Size de dos objetos MyFileInfoSet son iguales.

class MyFileInfoSet : System.IEquatable[Object] {
    [string]$File
    [int64]$Size

    [bool] Equals([Object] $obj) {
        return ($this.File -eq $obj.File) -and ($this.Size -eq $obj.Size)
    }
}
$a = [MyFileInfoSet]@{File = 'C:\Windows\explorer.exe'; Size = 4651032}
$b = [MyFileInfoSet]@{File = 'C:\Windows\explorer.exe'; Size = 4651032}
$a -eq $b

True

Un ejemplo destacado de comparación de objetos arbitrarios es averiguar si son NULL. Pero si necesita determinar si una variable es $null, debe colocar $null en el lado izquierdo del operador de igualdad. Colocarlo en el lado derecho no funciona como uno espera.

Por ejemplo, deje que $a ser una matriz que contenga elementos NULL:

$a = 1, 2, $null, 4, $null, 6

Lo siguiente prueba que $a no es nulo.

$null -ne $a

True

Sin embargo, lo siguiente filtra todos los elementos nulos de $a:

$a -ne $null # Output: 1, 2, 4, 6

-gt, -ge, -lt y -le

-gt, -ge, -lty -le se comportan de forma muy similar. Cuando ambos lados son escalares, devuelven True o False en función de cómo se comparan los dos lados:

Operador	Devuelve True cuando...
`-gt`	El lado izquierdo es mayor
`-ge`	El lado izquierdo es mayor o igual
`-lt`	El lado izquierdo es más pequeño
`-le`	El lado izquierdo es menor o igual

En los ejemplos siguientes, todas las declaraciones devuelven True.

8 -gt 6  # Output: True
8 -ge 8  # Output: True
6 -lt 8  # Output: True
8 -le 8  # Output: True

Nota

En la mayoría de los lenguajes de programación, el operador mayor que es >. En PowerShell, este carácter se usa para el redireccionamiento. Para obtener más información, consulte about_Redirection.

Cuando el lado izquierdo es una colección, estos operadores comparan cada miembro de la colección con el lado derecho. En función de su lógica, mantienen o descartan el miembro.

Ejemplo:

$a=5, 6, 7, 8, 9

Write-Output 'Test collection:'
$a

Write-Output "`nMembers greater than 7"
$a -gt 7

Write-Output "`nMembers greater than or equal to 7"
$a -ge 7

Write-Output "`nMembers smaller than 7"
$a -lt 7

Write-Output "`nMembers smaller than or equal to 7"
$a -le 7

Test collection:
5
6
7
8
9

Members greater than 7
8
9

Members greater than or equal to 7
7
8
9

Members smaller than 7
5
6

Members smaller than or equal to 7
5
6
7

Estos operadores funcionan con cualquier clase que implemente System.IComparable.

Ejemplos:

# Date comparison
[datetime]'2001-11-12' -lt [datetime]'2020-08-01' # True

# Sorting order comparison
'a' -lt 'z'           # True; 'a' comes before 'z'
'macOS' -ilt 'MacOS'  # False
'MacOS' -ilt 'macOS'  # False
'macOS' -clt 'MacOS'  # True; 'm' comes before 'M'

En el ejemplo siguiente se muestra que no hay ningún símbolo en un teclado QWERTY americano que se ordena después de "a". Alimenta un conjunto que contiene todos estos símbolos al operador -gt para compararlos con "a". La salida es una matriz vacía.

$a=' ','`','~','!','@','#','$','%','^','&','*','(',')','_','+','-','=',
   '{','}','[',']',':',';','"','''','\','|','/','?','.','>',',','<'
$a -gt 'a'
# Output: Nothing

Si los dos lados de los operadores no son razonablemente comparables, estos operadores generan un error infinito.

Operadores coincidentes

Los operadores coincidentes (-like, -notlike, -matchy -notmatch) buscan elementos que coinciden o no coinciden con un patrón especificado. El patrón de -like y -notlike es una expresión comodín (que contiene *, ?y [ ]), mientras que -match y -notmatch aceptan una expresión regular (regex).

La sintaxis es:

<string[]> -like    <wildcard-expression>
<string[]> -notlike <wildcard-expression>
<string[]> -match    <regular-expression>
<string[]> -notmatch <regular-expression>

Cuando la entrada de estos operadores es un valor escalar, devuelven un valor booleano.

Cuando la entrada es una colección de valores, cada elemento de la colección se convierte en una cadena para la comparación. Los operadores -match y -notmatch devuelven cualquier miembro que coincida y que no coincida, respectivamente. Sin embargo, los operadores -like y -notlike devuelven los miembros como cadenas. La cadena devuelta para un miembro de la colección por los operadores -like y -notlike es la cadena que el operador utilizó para la comparación y se obtiene mediante la conversión del miembro a una cadena.

-like y -notlike

-like y -notlike se comportan de forma similar a -eq y -ne, pero el lado derecho podría ser una cadena que contiene caracteres comodín.

Ejemplo:

'PowerShell' -like    '*shell'           # Output: True
'PowerShell' -notlike '*shell'           # Output: False
'PowerShell' -like    'Power?hell'       # Output: True
'PowerShell' -notlike 'Power?hell'       # Output: False
'PowerShell' -like    'Power[p-w]hell'   # Output: True
'PowerShell' -notlike 'Power[p-w]hell'   # Output: False

'PowerShell', 'Server' -like '*shell'    # Output: PowerShell
'PowerShell', 'Server' -notlike '*shell' # Output: Server

Para obtener los mejores resultados, el lado derecho de los -like operadores y -notlike debe ser un literal de cadena que contenga la expresión comodín. PowerShell pasa la expresión comodín al analizador de expresiones comodín. Para que coincida con uno de los caracteres comodín (*, , o ?), debe escaparlo con un carácter de retroceso ([ ]`). Por ejemplo, para que coincida con un literal ?, use `? en la expresión comodín. Si usa una expresión de cadena expandible, PowerShell expande la cadena antes de pasarla al analizador de caracteres comodín, lo que hace que los caracteres sin escape se envíen como caracteres comodín.

# Escaped literals in an expandable string
PS> "f`?`?"
f??
# Escaped literals in a literal string
PS> 'f`?`?'
f`?`?
# Comparison containing 2 wildcards
PS> 'f??' -like 'f??'
True
PS> 'for' -like 'f??'
True
# Comparison containing literal '?' characters
PS> 'f??' -like 'f`?`?'
True
PS> 'for' -like 'f`?`?'
False

-match y -notmatch

-match y -notmatch usan expresiones regulares para buscar patrones en los valores del lado izquierdo. Las expresiones regulares pueden coincidir con patrones complejos, como direcciones de correo electrónico, rutas de acceso UNC o números de teléfono con formato. La cadena del lado derecho debe cumplir las reglas de expresiones regulares .

Ejemplos escalares:

# Partial match test, showing how differently -match and -like behave
'PowerShell' -match 'shell'        # Output: True
'PowerShell' -like  'shell'        # Output: False

# Regex syntax test
'PowerShell' -match    '^Power\w+' # Output: True
'bag'        -notmatch 'b[iou]g'   # Output: True

Si la entrada es una colección, los operadores devuelven los miembros coincidentes de esa colección.

Ejemplos de colección:

'PowerShell', 'Super PowerShell', 'Power's hell' -match '^Power\w+'
# Output: PowerShell

'Rhell', 'Chell', 'Mel', 'Smell', 'Shell' -match 'hell'
# Output: Rhell, Chell, Shell

'Bag', 'Beg', 'Big', 'Bog', 'Bug'  -match 'b[iou]g'
#Output: Big, Bog, Bug

'Bag', 'Beg', 'Big', 'Bog', 'Bug'  -notmatch 'b[iou]g'
#Output: Bag, Beg

-match y -notmatch admiten grupos de captura de expresiones regulares. Cada vez que se ejecutan con una entrada escalar y el resultado de -match es True o el resultado de -notmatch es False, sobrescriben la variable automática $Matches. $Matches es un Hashtable que siempre tiene una clave denominada "0", que almacena toda la concordancia. Si la expresión regular contiene grupos de captura, el $Matches contiene claves adicionales para cada grupo.

Es importante tener en cuenta que la $Matches tabla hash contiene solo la primera aparición de cualquier patrón coincidente.

Ejemplo:

$string = 'The last logged on user was CONTOSO\jsmith'
$string -match 'was (?<domain>.+)\\(?<user>.+)'

$Matches

Write-Output "`nDomain name:"
$Matches.domain

Write-Output "`nUser name:"
$Matches.user

True

Name                           Value
----                           -----
domain                         CONTOSO
user                           jsmith
0                              was CONTOSO\jsmith

Domain name:
CONTOSO

User name:
jsmith

Cuando el resultado del -match es False, o el resultado del -notmatch es True, o cuando la entrada es una colección, la variable automática $Matches no se sobrescribe. Por lo tanto, contendrá el valor establecido anteriormente o $null si no se ha establecido la variable. Al hacer referencia a $Matches después de invocar uno de estos operadores, considere la posibilidad de comprobar que la variable se estableció mediante la invocación del operador actual mediante una instrucción condition.

Ejemplo:

if ('<version>1.0.0</version>' -match '<version>(.*?)</version>') {
    $Matches
}

Para obtener más información, consulte about_Regular_Expressions y about_Automatic_Variables.

Operador de reemplazo

Reemplazo con expresiones regulares

Al igual que -match, el operador -replace usa expresiones regulares para buscar el patrón especificado. Pero a diferencia de -match, reemplaza las coincidencias por otro valor especificado.

Sintaxis:

<input> -replace <regular-expression>, <substitute>

El operador reemplaza todo o parte de un valor por el valor especificado mediante expresiones regulares. Puede usar el operador 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 de .txt a .log:

Get-ChildItem *.txt | Rename-Item -NewName { $_.Name -replace '\.txt$','.log' }

De forma predeterminada, el operador -replace no distingue mayúsculas de minúsculas. Para distinguir mayúsculas de minúsculas, use -creplace. Para hacerlo explícitamente insensible a mayúsculas y minúsculas, use -ireplace.

Ejemplos:

'book' -ireplace 'B', 'C' # Case insensitive
'book' -creplace 'B', 'C' # Case-sensitive; hence, nothing to replace

Cook
book

A partir de PowerShell 7.2, cuando el operando izquierdo de una instrucción de operador -replace no es una cadena, ese operando se convierte en una cadena. PowerShell realiza una conversión de cadena insensible a la cultura.

Por ejemplo, si la cultura está establecida en francés (fr), la conversión de cadena sensible a la cultura del valor 1.2 es 1,2.

Antes de PowerShell 7.2:

PS> [cultureinfo]::CurrentCulture = 'fr'
PS> 1.2 -replace ','
12

En PowerShell 7.2 y versiones posteriores:

PS> [cultureinfo]::CurrentCulture = 'fr'
PS> 1.2 -replace ','
1.2

Sustituciones de expresiones regulares

También es posible usar expresiones regulares para reemplazar dinámicamente texto mediante grupos de captura y sustituciones. Se puede hacer referencia a los grupos de captura en la cadena de <substitute> mediante el carácter de signo de dólar ($) que precede al identificador del grupo.

En el ejemplo siguiente, el operador -replace acepta un nombre de usuario en forma de DomainName\Username y convierte al formato Username@DomainName:

$SearchExp = '^(?<DomainName>[\w-.]+)\\(?<Username>[\w-.]+)$'
$ReplaceExp = '${Username}@${DomainName}'

'Contoso.local\John.Doe' -replace $SearchExp, $ReplaceExp

John.Doe@Contoso.local

Advertencia

El carácter $ tiene roles sintácticos tanto en PowerShell como en expresiones regulares:

En PowerShell, entre comillas dobles, designa variables y actúa como un operador de subexpresión.
En las cadenas de búsqueda con regex, denota el final de la línea.
En las cadenas de sustitución Regex, denota los grupos capturados. Asegúrate de colocar las expresiones regulares entre comillas simples o insertar un carácter de acento grave (`) antes de ellas.

Por ejemplo:

$1 = 'Goodbye'

'Hello World' -replace '(\w+) \w+', "$1 Universe"
# Output: Goodbye Universe

'Hello World' -replace '(\w+) \w+', '$1 Universe'
# Output: Hello Universe

$$ en Regex indica un literal $. Esta $$ en la cadena de sustitución para incluir un literal $ en la sustitución resultante. Por ejemplo:

'5.72' -replace '(.+)', '$ $1' # Output: $ 5.72
'5.72' -replace '(.+)', '$$$1' # Output: $5.72
'5.72' -replace '(.+)', '$$1'  # Output: $1

Para obtener más información, consulte about_Regular_Expressions y Sustituciones en expresiones regulares.

Sustitución en una colección

Cuando el operador <input> a -replace es una colección, PowerShell aplica el reemplazo a cada valor de la colección. Por ejemplo:

'B1','B2','B3','B4','B5' -replace 'B', 'a'
a1
a2
a3
a4
a5

Reemplazo con un bloque de scripts

En PowerShell 6 y versiones posteriores, el -replace operador también acepta un scriptblock que realiza el reemplazo. El scriptblock se ejecuta una vez para cada coincidencia.

Sintaxis:

<String> -replace <regular-expression>, {<Script-block>}

En el scriptblock, use la $_ variable automática para acceder al texto de entrada que se va a reemplazar y otra información útil. El tipo de clase de esta variable es System.Text.RegularExpressions.Match.

En el ejemplo siguiente se reemplaza cada secuencia de tres dígitos por los equivalentes de caracteres. El scriptblock se ejecuta para cada conjunto de tres dígitos que se deben reemplazar.

'072101108108111' -replace '\d{3}', {return [char][int]$_.Value}

Hello

Operadores de contención

Los operadores de contención (, , y ) son similares a los operadores de igualdad, excepto que siempre devuelven un valor de booleano , incluso cuando la entrada es una colección. Estos operadores dejan de comparar tan pronto como detectan la primera coincidencia, mientras que los operadores de igualdad evalúan todos los elementos de entrada. En una colección muy grande, estos operadores devuelven resultados más rápidamente que los operadores de igualdad.

-contains y -notcontains

Sintaxis:

<Collection> -contains <scalar-object>
<Collection> -notcontains <scalar-object>

Estos operadores indican si un conjunto incluye un determinado elemento. -contains devuelve True cuando el lado derecho (objeto escalar) coincide con uno de los elementos del conjunto. -notcontains devuelve False en su lugar.

Ejemplos:

'abc', 'def' -contains 'def'                  # Output: True
'abc', 'def' -notcontains 'def'               # Output: False
'Windows', 'PowerShell' -contains 'Shell'     # Output: False
'Windows', 'PowerShell' -notcontains 'Shell'  # Output: True
'abc', 'def', 'ghi' -contains 'abc', 'def'    # Output: False
'abc', 'def', 'ghi' -notcontains 'abc', 'def' # Output: True

Ejemplos más complejos:

$DomainServers = 'ContosoDC1', 'ContosoDC2', 'ContosoFileServer',
                 'ContosoDNS', 'ContosoDHCP', 'ContosoWSUS'
$thisComputer  = 'ContosoDC2'

$DomainServers -contains $thisComputer
# Output: True

Cuando el operando del lado derecho es una colección, estos operadores convierten el valor en su representación de cadena antes de compararlo con la colección del lado izquierdo.

$a = 'abc', 'def'
'abc', 'def', 'ghi' -contains $a # Output: False

# The following statements are equivalent
$a, 'ghi' -contains $a           # Output: True
'$a', 'ghi' -contains $a         # Output: True
'abc def', 'ghi' -contains $a    # Output: True

-in y -notin

Sintaxis:

<scalar-object> -in <Collection>
<scalar-object> -notin <Collection>

Los operadores -in y -notin se introdujeron en PowerShell 3 como la inversa sintáctica de los operadores de -contains y -notcontains. -in devuelve True cuando el lado izquierdo <scalar-object> coincide con uno de los elementos de la colección. -notin devuelve False en su lugar.

Los ejemplos siguientes hacen lo mismo que hacen los ejemplos de -contains y -notcontains, pero se escriben con -in y -notin en su lugar.

'def' -in 'abc', 'def'                  # Output: True
'def' -notin 'abc', 'def'               # Output: False
'Shell' -in 'Windows', 'PowerShell'     # Output: False
'Shell' -notin 'Windows', 'PowerShell'  # Output: True
'abc', 'def' -in 'abc', 'def', 'ghi'    # Output: False
'abc', 'def' -notin 'abc', 'def', 'ghi' # Output: True

Ejemplos más complejos:

$DomainServers = 'ContosoDC1', 'ContosoDC2', 'ContosoFileServer',
                 'ContosoDNS', 'ContosoDHCP', 'ContosoWSUS'
$thisComputer  = 'ContosoDC2'

$thisComputer -in $DomainServers
# Output: True

Cuando el operando izquierdo es una colección, estos operadores convierten el valor en su representación de cadena antes de compararlo con la colección del lado derecho.

$a = 'abc', 'def'
$a -in 'abc', 'def', 'ghi' # Output: False

# The following statements are equivalent
$a -in $a, 'ghi'           # Output: True
$a -in '$a', 'ghi'         # Output: True
$a -in 'abc def', 'ghi'    # Output: True

Comparación de tipos

Los operadores de comparación de tipos (-is y -isnot) se usan para determinar si un objeto es un tipo específico.

Sintaxis:

<object> -is <type-reference>
<object> -isnot <type-reference>

Ejemplo:

$a = 1
$b = '1'
$a -is [int]           # Output: True
$a -is $b.GetType()    # Output: False
$b -isnot [int]        # Output: True
$a -isnot $b.GetType() # Output: True

Consulte también

Comentarios

¿Le ha resultado útil esta página?

Last updated on 2026-01-18

Compartir a través de

acerca_de_Operadores_de_Comparación

Descripción breve

Descripción larga

Características comunes

Operadores de igualdad

-eq y -ne

-gt, -ge, -lt y -le

Operadores coincidentes

-like y -notlike

-match y -notmatch

Operador de reemplazo

Reemplazo con expresiones regulares

Sustituciones de expresiones regulares

Sustitución en una colección

Reemplazo con un bloque de scripts

Operadores de contención

-contains y -notcontains

-in y -notin

Comparación de tipos

Consulte también

Comentarios

Recursos adicionales