Acerca de los operadores de comparaciónAbout Comparison Operators

Descripción breveShort description

Describe los operadores que comparan valores en PowerShell.Describes the operators that compare values in PowerShell.

Descripción largaLong description

Los operadores de comparación permiten especificar condiciones para comparar valores y buscar valores que coincidan con los patrones especificados.Comparison operators let you specify conditions for comparing values and finding values that match specified patterns. Para usar un operador de comparación, especifique los valores que desea comparar junto con un operador que separe estos valores.To use a comparison operator, specify the values that you want to compare together with an operator that separates these values.

PowerShell incluye los siguientes operadores de comparación:PowerShell includes the following comparison operators:

TipoType OperadoresOperators DescripciónDescription
IgualdadEquality -eq-eq equalsequals
-ne-ne no es igual anot equals
-gt-gt mayor quegreater than
-ge-ge mayor o igualgreater than or equal
-lt-lt menor queless than
-le-le menor o igualless than or equal
MatchingMatching -like-like Devuelve verdadero cuando la cadena coincide con el carácter comodínReturns true when string matches wildcard
patternpattern
-notlike-notlike Devuelve verdadero cuando la cadena no coincideReturns true when string does not match
patrón de carácter comodínwildcard pattern
-match-match Devuelve verdadero cuando la cadena coincide con regexReturns true when string matches regex
ajedrez $matches contiene cadenas coincidentespattern; $matches contains matching strings
-notmatch-notmatch Devuelve verdadero cuando la cadena no coincideReturns true when string does not match
patrón Regex; $matches contiene coincidenciaregex pattern; $matches contains matching
cadenasstrings
ContainmentContainment -contains-contains Devuelve verdadero cuando el valor de referencia contieneReturns true when reference value contained
en una colecciónin a collection
-notcontains-notcontains Devuelve verdadero cuando el valor de referencia no esReturns true when reference value not
contenido en una coleccióncontained in a collection
-in-in Devuelve verdadero cuando el valor de prueba se encuentra en unReturns true when test value contained in a
collectioncollection
-notin-notin Devuelve verdadero cuando el valor de prueba no está incluidoReturns true when test value not contained
en una colecciónin a collection
ReplacementReplacement -reemplazar-replace Reemplaza un patrón de cadenaReplaces a string pattern
TipoType -es-is Devuelve true si ambos objetos son iguales.Returns true if both object are the same
typetype
-IsNot-isnot Devuelve true si los objetos no son iguales.Returns true if the objects are not the same
typetype

De forma predeterminada, todos los operadores de comparación no distinguen mayúsculas de minúsculas.By default, all comparison operators are case-insensitive. Para hacer que un operador de comparación distinga entre mayúsculas y minúsculas, debe anteponer al nombre del operador c .To make a comparison operator case-sensitive, precede the operator name with a c. Por ejemplo, la versión que distingue entre mayúsculas y minúsculas de -eq es -ceq .For example, the case-sensitive version of -eq is -ceq. Para hacer que la distinción de mayúsculas y minúsculas sea explícita, anteponga a un operador i .To make the case-insensitivity explicit, precede the operator with an i. Por ejemplo, la versión explícitamente que no distingue mayúsculas de minúsculas de -eq es -ieq .For example, the explicitly case-insensitive version of -eq is -ieq.

Cuando la entrada para un operador es un valor escalar, los operadores de comparación devuelven un valor booleano.When the input to an operator is a scalar value, comparison operators return a Boolean value. Cuando la entrada es una colección de valores, los operadores de comparación devuelven los valores coincidentes.When the input is a collection of values, the comparison operators return any matching values. Si no hay ninguna coincidencia en una colección, los operadores de comparación devuelven una matriz vacía.If there are no matches in a collection, comparison operators return an empty array.

PS> (1, 2 -eq 3).GetType().FullName
System.Object[]

Las excepciones son los operadores de contención, los operadores in y los operadores de tipo, que siempre devuelven un valor booleano .The exceptions are the containment operators, the In operators, and the type operators, which always return a Boolean value.

Nota

Si necesita comparar un valor con $null , debe colocar $null en el lado izquierdo de la comparación.If you need to compare a value to $null you should put $null on the left-hand side of the comparison. Al comparar $null con un objeto [] , el resultado es false porque el objeto de comparación es una matriz.When you compare $null to an Object[] the result is False because the comparison object is an array. Al comparar una matriz con $null , la comparación filtra los $null valores almacenados en la matriz.When you compare an array to $null, the comparison filters out any $null values stored in the array. Por ejemplo:For example:

PS> $null -ne $null, "hello"
True
PS> $null, "hello" -ne $null
hello

Operadores de igualdadEquality operators

Los operadores de igualdad ( -eq , -ne ) devuelven un valor true o coinciden cuando uno o varios de los valores de entrada son idénticos al patrón especificado.The equality operators (-eq, -ne) return a value of TRUE or the matches when one or more of the input values is identical to the specified pattern. Todo el patrón debe coincidir con un valor completo.The entire pattern must match an entire value.

Ejemplo:Example:

-eq-eq

Descripción: es igual a.Description: Equal to. Incluye un valor idéntico.Includes an identical value.

Ejemplo:Example:

PS> 2 -eq 2
True

PS> 2 -eq 3
False

PS> 1,2,3 -eq 2
2
PS> "abc" -eq "abc"
True

PS> "abc" -eq "abc", "def"
False

PS> "abc", "def" -eq "abc"
abc

-ne-ne

Descripción: no es igual a.Description: Not equal to. Incluye un valor diferente.Includes a different value.

Ejemplo:Example:

PS> "abc" -ne "def"
True

PS> "abc" -ne "abc"
False

PS> "abc" -ne "abc", "def"
True

PS> "abc", "def" -ne "abc"
def

-gt-gt

Descripción: mayor que.Description: Greater-than.

Ejemplo:Example:

PS> 8 -gt 6
True

PS> 7, 8, 9 -gt 8
9

Nota

No debe confundirse con > , el operador mayor que en muchos otros lenguajes de programación.This should not to be confused with >, the greater-than operator in many other programming languages. En PowerShell, > se usa para la redirección.In PowerShell, > is used for redirection. Para obtener más información, vea About_redirection.For more information, see About_redirection.

-ge-ge

Descripción: mayor o igual que.Description: Greater-than or equal to.

Ejemplo:Example:

PS> 8 -ge 8
True

PS> 7, 8, 9 -ge 8
8
9

-lt-lt

Descripción: menor que.Description: Less-than.

Ejemplo:Example:


PS> 8 -lt 6
False

PS> 7, 8, 9 -lt 8
7

-le-le

Descripción: menor o igual que.Description: Less-than or equal to.

Ejemplo:Example:

PS> 6 -le 8
True

PS> 7, 8, 9 -le 8
7
8

Operadores coincidentesMatching operators

Los operadores Like ( -like y -notlike ) buscan los elementos que coinciden o no coinciden con un patrón especificado mediante expresiones comodín.The like operators (-like and -notlike) find elements that match or do not match a specified pattern using wildcard expressions.

La sintaxis es:The syntax is:

<string[]> -like <wildcard-expression>
<string[]> -notlike <wildcard-expression>

Los operadores de coincidencia ( -match y -notmatch ) buscan los elementos que coinciden o no coinciden con un patrón especificado mediante expresiones regulares.The match operators (-match and -notmatch) find elements that match or do not match a specified pattern using regular expressions.

Los operadores de coincidencia rellenan la $Matches variable automática cuando la entrada (el argumento de la izquierda) al operador es un objeto escalar único.The match operators populate the $Matches automatic variable when the input (the left-side argument) to the operator is a single scalar object. Cuando la entrada es escalar, -match los -notmatch operadores y devuelven un valor booleano y establecen el valor de la $Matches variable automática en los componentes coincidentes del argumento.When the input is scalar, the -match and -notmatch operators return a Boolean value and set the value of the $Matches automatic variable to the matched components of the argument.

La sintaxis es:The syntax is:

<string[]> -match <regular-expression>
<string[]> -notmatch <regular-expression>

-like-like

Descripción: coincide con el carácter comodín ( * ).Description: Match using the wildcard character (*).

Ejemplo:Example:

PS> "PowerShell" -like "*shell"
True

PS> "PowerShell", "Server" -like "*shell"
PowerShell

-notlike-notlike

Descripción: no coincide con el carácter comodín ( * ).Description: Does not match using the wildcard character (*).

Ejemplo:Example:

PS> "PowerShell" -notlike "*shell"
False

PS> "PowerShell", "Server" -notlike "*shell"
Server

-match-match

Descripción: coincide con una cadena mediante expresiones regulares.Description: Matches a string using regular expressions. Cuando la entrada es escalar, rellena la $Matches variable automática.When the input is scalar, it populates the $Matches automatic variable.

Si la entrada es una colección, los -match -notmatch operadores y devuelven los miembros coincidentes de esa colección, pero el operador no rellena la $Matches variable.If the input is a collection, the -match and -notmatch operators return the matching members of that collection, but the operator does not populate the $Matches variable.

Por ejemplo, el comando siguiente envía una colección de cadenas al -match operador.For example, the following command submits a collection of strings to the -match operator. El -match operador devuelve los elementos de la colección que coinciden.The -match operator returns the items in the collection that match. No rellena la $Matches variable automática.It does not populate the $Matches automatic variable.

PS> "Sunday", "Monday", "Tuesday" -match "sun"
Sunday

PS> $Matches
PS>

En cambio, el comando siguiente envía una sola cadena al -match operador.In contrast, the following command submits a single string to the -match operator. El -match operador devuelve un valor booleano y rellena la $Matches variable automática.The -match operator returns a Boolean value and populates the $Matches automatic variable. La $Matches variable automática es una tabla hash.The $Matches automatic variable is a Hashtable. Si no se usa ninguna agrupación ni captura, solo se rellena una clave.If no grouping or capturing is used, only one key is populated. La 0 clave representa todo el texto con el que se encontró una coincidencia.The 0 key represents all text that was matched. Para obtener más información sobre la agrupación y la captura mediante expresiones regulares, vea about_Regular_Expressions.For more information about grouping and capturing using regular expressions, see about_Regular_Expressions.

PS> "Sunday" -match "sun"
True

PS> $Matches

Name                           Value
----                           -----
0                              Sun

Es importante tener en cuenta que la $Matches tabla hash solo contendrá la primera aparición de cualquier patrón coincidente.It is important to note that the $Matches hashtable will only contain the first occurrence of any matching pattern.

PS> "Banana" -match "na"
True

PS> $Matches

Name                           Value
----                           -----
0                              na

Importante

La 0 clave es un entero.The 0 key is an Integer. Puede usar cualquier método Hashtable para tener acceso al valor almacenado.You can use any Hashtable method to access the value stored.

PS> "Good Dog" -match "Dog"
True

PS> $Matches[0]
Dog

PS> $Matches.Item(0)
Dog

PS> $Matches.0
Dog

El -notmatch operador rellena la $Matches variable automática cuando la entrada es escalar y el resultado es false, es decir, cuando detecta una coincidencia.The -notmatch operator populates the $Matches automatic variable when the input is scalar and the result is False, that it, when it detects a match.

PS> "Sunday" -notmatch "rain"
True

PS> $matches
PS>

PS> "Sunday" -notmatch "day"
False

PS> $matches

Name                           Value
----                           -----
0                              day

-notmatch-notmatch

Descripción: no coincide con una cadena.Description: Does not match a string. Utiliza expresiones regulares.Uses regular expressions. Cuando la entrada es escalar, rellena la $Matches variable automática.When the input is scalar, it populates the $Matches automatic variable.

Ejemplo:Example:

PS> "Sunday" -notmatch "sun"
False

PS> $matches
Name Value
---- -----
0    sun

PS> "Sunday", "Monday" -notmatch "sun"
Monday

Operadores de contenciónContainment operators

Los operadores de contención ( -contains y -notcontains ) son similares a los operadores de igualdad.The containment operators (-contains and -notcontains) are similar to the equality operators. Sin embargo, los operadores de contención siempre devuelven un valor booleano, incluso cuando la entrada es una colección.However, the containment operators always return a Boolean value, even when the input is a collection.

Además, a diferencia de los operadores de igualdad, los operadores de contención devuelven un valor en cuanto detectan la primera coincidencia.Also, unlike the equality operators, the containment operators return a value as soon as they detect the first match. Los operadores de igualdad evalúan todas las entradas y, a continuación, devuelven todas las coincidencias de la colección.The equality operators evaluate all input and then return all the matches in the collection.

-contains-contains

Descripción: operador de contención.Description: Containment operator. Indica si una colección de valores de referencia incluye un solo valor de prueba.Tells whether a collection of reference values includes a single test value. Siempre devuelve un valor booleano.Always returns a Boolean value. Devuelve TRUE solo cuando el valor de prueba coincide exactamente con al menos uno de los valores de referencia.Returns TRUE only when the test value exactly matches at least one of the reference values.

Cuando el valor de prueba es una colección, el operador Contains usa la igualdad de referencia.When the test value is a collection, the Contains operator uses reference equality. Solo devuelve TRUE cuando uno de los valores de referencia es la misma instancia del objeto de valor de prueba.It returns TRUE only when one of the reference values is the same instance of the test value object.

En una colección muy grande, el -contains operador devuelve resultados más rápido que el operador igual a.In a very large collection, the -contains operator returns results quicker than the equal to operator.

Sintaxis:Syntax:

<Reference-values> -contains <Test-value>

Ejemplos:Examples:

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

PS> "Windows", "PowerShell" -contains "Shell"
False  #Not an exact match

# Does the list of computers in $DomainServers include $ThisComputer?
PS> $DomainServers -contains $thisComputer
True

PS> "abc", "def", "ghi" -contains "abc", "def"
False

PS> $a = "abc", "def"
PS> "abc", "def", "ghi" -contains $a
False
PS> $a, "ghi" -contains $a
True

-notcontains-notcontains

Descripción: operador de contención.Description: Containment operator. Indica si una colección de valores de referencia incluye un solo valor de prueba.Tells whether a collection of reference values includes a single test value. Siempre devuelve un valor booleano.Always returns a Boolean value. Devuelve verdadero cuando el valor de prueba no coincide exactamente con al menos uno de los valores de referencia.Returns TRUE when the test value is not an exact matches for at least one of the reference values.

Cuando el valor de prueba es una colección, el operador NotContains usa la igualdad de referencia.When the test value is a collection, the NotContains operator uses reference equality.

Sintaxis:Syntax:

<Reference-values> -notcontains <Test-value>

Ejemplos:Examples:

PS> "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> $ApprovedVerbs = Get-Verb | foreach {$_.verb}
PS> $myVerbs = Get-Command -Module MyModule | foreach {$_.verb}
PS> $myVerbs | where {$ApprovedVerbs -notcontains $_}
ForEach
Sort
Tee
Where

-in-in

Descripción: operador in.Description: In operator. Indica si un valor de prueba aparece en una colección de valores de referencia.Tells whether a test value appears in a collection of reference values. Devuelva siempre como valor booleano.Always return as Boolean value. Devuelve TRUE solo cuando el valor de prueba coincide exactamente con al menos uno de los valores de referencia.Returns TRUE only when the test value exactly matches at least one of the reference values.

Cuando el valor de prueba es una colección, el operador in usa la igualdad de referencia.When the test value is a collection, the In operator uses reference equality. Solo devuelve TRUE cuando uno de los valores de referencia es la misma instancia del objeto de valor de prueba.It returns TRUE only when one of the reference values is the same instance of the test value object.

El -in operador se presentó en PowerShell 3,0.The -in operator was introduced in PowerShell 3.0.

Sintaxis:Syntax:

<Test-value> -in <Reference-values>

Ejemplos:Examples:

PS> "def" -in "abc", "def"
True

PS> "Shell" -in "Windows", "PowerShell"
False  #Not an exact match

PS> "Windows" -in "Windows", "PowerShell"
True  #An exact match

PS> "Windows", "PowerShell" -in "Windows", "PowerShell", "ServerManager"
False  #Using reference equality

PS> $a = "Windows", "PowerShell"
PS> $a -in $a, "ServerManager"
True  #Using reference equality

# Does the list of computers in $DomainServers include $ThisComputer?
PS> $thisComputer -in  $domainServers
True

-notin-notin

Descripción: indica si un valor de prueba aparece en una colección de valores de referencia.Description: Tells whether a test value appears in a collection of reference values. Siempre devuelve un valor booleano.Always returns a Boolean value. Devuelve verdadero cuando el valor de prueba no coincide exactamente con al menos uno de los valores de referencia.Returns TRUE when the test value is not an exact match for at least one of the reference values.

Cuando el valor de prueba es una colección, el operador in usa la igualdad de referencia.When the test value is a collection, the In operator uses reference equality. Solo devuelve TRUE cuando uno de los valores de referencia es la misma instancia del objeto de valor de prueba.It returns TRUE only when one of the reference values is the same instance of the test value object.

El -notin operador se presentó en PowerShell 3,0.The -notin operator was introduced in PowerShell 3.0.

Sintaxis:Syntax:

<Test-value> -notin <Reference-values>

Ejemplos:Examples:

PS> "def" -notin "abc", "def"
False

PS> "ghi" -notin "abc", "def"
True

PS> "Shell" -notin "Windows", "PowerShell"
True  #Not an exact match

PS> "Windows" -notin "Windows", "PowerShell"
False  #An exact match

# Find unapproved verbs in the functions in my module
PS> $ApprovedVerbs = Get-Verb | foreach {$_.verb}
PS> $MyVerbs = Get-Command -Module MyModule | foreach {$_.verb}

PS> $MyVerbs | where {$_ -notin $ApprovedVerbs}
ForEach
Sort
Tee
Where

Operador de reemplazoReplacement Operator

El -replace operador tiene la siguiente sintaxis:The -replace operator has the following syntax:

<input> -replace <original>, <substitute>

El <original> marcador de posición es una expresión regular que coincide con los caracteres que se van a reemplazar.The <original> placeholder is a regular expression matching the characters to be replaced. El <substitute> marcador de posición es una cadena literal que los reemplaza.The <substitute> placeholder is a literal string that replaces them.

El operador reemplaza todo o parte de un valor con el valor especificado mediante expresiones regulares.The operator replaces all or part of a value with the specified value using regular expressions. Puede usar el operador para muchas tareas administrativas, como cambiar el nombre de los archivos.You can use the operator for many administrative tasks, such as renaming files. Por ejemplo, el siguiente comando cambia las extensiones de nombre de archivo de todos los .txt archivos a .log :For example, the following command changes the file name extensions of all .txt files to .log:

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

Concordancias con distinción entre mayúsculas y minúsculasCase-sensitive matches

De forma predeterminada, el -replace operador no distingue mayúsculas de minúsculas.By default, the -replace operator is case-insensitive. Para hacer que distinga mayúsculas de minúsculas, use -creplace .To make it case sensitive, use -creplace. Para que no distinga entre mayúsculas y minúsculas, use -ireplace .To make it explicitly case-insensitive, use -ireplace.

Considere los siguientes ejemplos:Consider the following examples:

PS> "book" -replace "B", "C"
Cook
PS> "book" -ireplace "B", "C"
Cook
PS> "book" -creplace "B", "C"
book

Sustituciones en expresiones regularesSubstitutions in regular expressions

También es posible usar expresiones regulares para reemplazar texto de forma dinámica mediante los grupos de captura y las sustituciones.It is also possible to use regular expressions to dynamically replace text using capturing groups, and substitutions. Se puede hacer referencia a los grupos de captura en la <substitute> cadena mediante el carácter de signo de dólar ( $ ) antes del identificador de grupo.Capture groups can be referenced in the <substitute> string using the dollar sign ($) character before the group identifier.

Se puede hacer referencia a los grupos de captura por número o nombreCapture groups can be referenced by Number or Name

  • Por número : los grupos de captura se numeran de izquierda a derecha.By Number - Capturing Groups are numbered from left to right.

    PS> "John D. Smith" -replace "(\w+) (\w+)\. (\w+)", '$1.$2.$3@contoso.com'
    John.D.Smith@contoso.com
    
  • Por nombre, también se puede hacer referencia a los grupos de captura por nombre.By Name - Capturing Groups can also be referenced by name.

    PS> "CONTOSO\Administrator" -replace '\w+\\(?<user>\w+)', 'FABRIKAM\${user}'
    FABRIKAM\Administrator
    

Advertencia

Dado que el $ carácter se usa en la expansión de cadenas, debe usar cadenas literales o escapar el $ carácter.Since the $ character is used in string expansion, you will must use literal strings or escape the $ character.

PS> 'Hello World' -replace '(\w+) \w+', "`$1 Universe"
Hello Universe

Además, puesto que el $ carácter se usa en la sustitución, debe omitir todas las instancias de la cadena.Additionally, since the $ character is used in substitution, you must escape any instances in your string.

PS> '5.72' -replace '(.+)', '$$$1'
$5.72

Para obtener más información, consulte about_Regular_Expressions y sustituciones en expresiones regulares .To learn more see about_Regular_Expressions and Substitutions in Regular Expressions

Sustituir en una colecciónSubstituting in a collection

Cuando el <input> para el -replace operador es una colección, PowerShell aplica el reemplazo a cada valor de la colección.When the <input> to the -replace operator is a collection, PowerShell applies the replacement to every value in the collection. Por ejemplo:For example:

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

Sustituciones de ScriptBlockScriptBlock substitutions

A partir de PowerShell 6, puede usar un argumento ScriptBlock para el texto de sustitución .Beginning in PowerShell 6, you can use a ScriptBlock argument for the Substitution text. El ScriptBlock se ejecutará para cada coincidencia encontrada en la cadena de entrada .The ScriptBlock will execute for each match found in the input string.

Dentro del ScriptBlock, use la $_ variable automática para hacer referencia al objeto System. Text. RegularExpressions. Match actual.Within the ScriptBlock, use the $_ automatic variable to refer to the current System.Text.RegularExpressions.Match object. El objeto Match proporciona acceso al texto de entrada actual que se va a reemplazar, así como a otra información útil.The Match object gives you access to the current input text being replaced, as well as other useful information.

En este ejemplo se reemplaza cada secuencia de tres decimales por el carácter equivalente.This example replaces each sequence of three decimals with the character equivalent. El ScriptBlock se ejecuta para cada conjunto de tres decimales que debe reemplazarse.The ScriptBlock is run for each set of three decimals that needs to be replaced.

PS> "072101108108111" -replace "\d{3}", {[char][int]$_.Value}
Hello

Comparación de tiposType comparison

Los operadores de comparación de tipos ( -is y -isnot ) se usan para determinar si un objeto es un tipo específico.The type comparison operators (-is and -isnot) are used to determine if an object is a specific type.

-es-is

Sintaxis:Syntax:

<object> -is <type reference>

Ejemplo:Example:

PS> $a = 1
PS> $b = "1"
PS> $a -is [int]
True
PS> $a -is $b.GetType()
False

-IsNot-isnot

Sintaxis:Syntax:

<object> -isnot <type reference>

Ejemplo:Example:

PS> $a = 1
PS> $b = "1"
PS> $a -isnot $b.GetType()
True
PS> $b -isnot [int]
True

Consulta tambiénSee also