about_Comparison_Operators

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 es igual a
• -gt, , -igt- -cgt mayor que
• -ge, , : -ige-cge mayor o igual que
• -lt, , -ilt- -clt menor que
• -le, , : -ile-cle menor o igual que

Coincidencia

• -like, , -ilike: -clike 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 cadena coincide con el patrón regex
• -notmatch, , -inotmatch-cnotmatch : la cadena no coincide con el patrón regex

Sustitución

• -replace, , -ireplace-creplace : reemplaza las 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 : el valor está en una colección.
• -notin : el valor no está en una colección

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 mayúsculas de minúsculas a menos que use el operador explícito que distingue mayúsculas de minúsculas. Para que un operador de comparación distingue mayúsculas de minúsculas, agregue un elemento c después de -. Por ejemplo, -ceq es la versión que distingue mayúsculas de minúsculas de -eq. Para que la distinción entre mayúsculas y minúsculas sea explícita, agregue una i excepción después -de . Por ejemplo, -ieq es la versión que no distingue mayúsculas de minúsculas explícitamente de -eq.

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

Cuando la entrada de un operador es un valor escalar , el operador devuelve un valor booleano . Cuando la entrada es una colección, el operador devuelve los elementos de la colección que coinciden con el valor derecho de la expresión. 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 .
• El -replace operador devuelve el resultado de reemplazo.
• Los -match operadores y -notmatch también rellenan la $Matches variable automática 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 -ne los filtra.

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 del valor del lado izquierdo para la comparación.

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 dos objetos, no solo una colección o escalar. 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.IEquatable<T> y tiene dos propiedades, File y Size. El Equals() método 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 hace lo que espera.

Por ejemplo, vamos a $a ser una matriz que contiene elementos NULL:

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

Las siguientes pruebas que $a no son null.

$null -ne $a

True

Sin embargo, los archivos eliminan todos los elementos NULL de $a:

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

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 que

En los ejemplos siguientes, todas las instrucciones devuelven True.

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

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 -gt operador 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 de no terminación.

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 -match operadores y -notmatch devuelven los miembros coincidentes y no coincidentes respectivamente. Sin embargo, los -like operadores y -notlike devuelven los miembros como cadenas. La cadena devuelta para un miembro de la colección por -like y -notlike es la cadena por la que el operador utilizado 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

-match y -notmatch

-match y -notmatch usan expresiones regulares para buscar el patrón 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 en la entrada escalar y el -match resultado es True o el -notmatch resultado es False, sobrescriben la $Matches variable automática. $Matches es una tabla Hash que siempre tiene una clave denominada "0", que almacena toda la coincidencia. Si la expresión regular contiene grupos de captura, contiene $Matches 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 -match resultado es False o el -notmatch resultado es True o cuando la entrada es una colección, la $Matches variable automática no se sobrescribe. Por lo tanto, contendrá el valor establecido anteriormente o $null si la variable no se ha establecido. Al hacer referencia $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 -replace operador usa expresiones regulares para buscar el patrón especificado. Pero a diferencia -matchde , 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 siguiente comando cambia las extensiones de nombre de archivo de todos los .txt archivos a .log:

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

De forma predeterminada, el -replace operador no distingue mayúsculas de minúsculas. Para distinguir mayúsculas de minúsculas, use -creplace. Para que no distingue mayúsculas de minúsculas explícitamente, 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 -replace instrucción de operador no es una cadena, ese operando se convierte en una cadena. PowerShell realiza una conversión de cadena que no distingue referencia cultural.

Por ejemplo, si la referencia cultural está establecida en francés (fr), la conversión de cadena que distingue la referencia cultural 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 grupos de captura en la <substitute> cadena mediante el carácter de signo de dólar ($) antes del identificador de grupo.

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

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

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

John.Doe@Contoso.local

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 $. Esto en $$ la cadena de sustitución para incluir un literal $ en el reemplazo 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.

Sustituir en una colección

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

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

Reemplazo por un bloque de script

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

Sintaxis:

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

Dentro del bloque de script, 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 bloque de script 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 (-contains, -notcontains, -iny -notin) son similares a los operadores de igualdad, salvo que siempre devuelven un valor booleano , incluso cuando la entrada es una colección. Estos operadores dejan de compararse tan pronto como detectan la primera coincidencia, mientras que los operadores de igualdad evalúan todos los miembros de entrada. En una colección muy grande, estos operadores devuelven más rápido 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 -in operadores y -notin se introdujeron en PowerShell 3 como la inversa sintáctica de los operadores y -contains-notcontains . -in devuelve True cuando el lado <scalar-object> izquierdo coincide con uno de los elementos de la colección. -notin devuelve False en su lugar.

Los ejemplos siguientes hacen lo mismo que los ejemplos para -contains y -notcontains lo hacen, 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

• about_Booleans
• about_Operators
• about_Regular_Expressions
• about_Wildcards
• Compare-Object
• Foreach-Object
• Where-Object