Share via

about_Operator_Precedence

  • Artículo

Descripción breve

Enumera los operadores de PowerShell en orden de precedencia.

Descripción larga

Los operadores de PowerShell permiten construir expresiones sencillas, pero eficaces. En este tema se enumeran los operadores en orden de precedencia. El orden de precedencia es el orden en el que PowerShell evalúa los operadores cuando aparecen varios operadores en la misma expresión.

Cuando los operadores tienen la misma precedencia, PowerShell los evalúa de izquierda a derecha a medida que aparecen dentro de la expresión. Las excepciones son los operadores de asignación, los operadores de conversión y los operadores de negación (!, -not, -bnot), que se evalúan de derecha a izquierda.

Puede usar gabinetes, como paréntesis, para invalidar el orden de precedencia estándar y forzar a PowerShell a evaluar la parte delimitada de una expresión antes de una parte no cerrada.

En la lista siguiente, los operadores aparecen en el orden en que se evalúan. Los operadores de la misma línea, o en el mismo grupo, tienen la misma prioridad.

La columna Operador enumera los operadores. En la columna Referencia se muestra el tema ayuda de PowerShell en el que se describe el operador. Para mostrar el tema, escriba get-help <topic-name>.

OPERATOR REFERENCIA
$() @() () @{} about_Operators
. ?. (acceso de miembro) about_Operators
:: (estático) about_Operators
[0] ?[0] (operador de índice) about_Operators
[int] (operadores de conversión) about_Operators
-split (unario) about_Split
-join (unario) about_Join
, (operador de coma) about_Operators
++ -- about_Assignment_Operators
! -not about_Logical_Operators
.. (operador range) about_Operators
-f (operador format) about_Operators
- (unario/negativo) about_Arithmetic_Operators
* / % about_Arithmetic_Operators
+ - about_Arithmetic_Operators

El siguiente grupo de operadores tiene la misma prioridad. Sus variantes que distinguen mayúsculas de minúsculas y distinguen mayúsculas de minúsculas explícitamente tienen la misma prioridad.

OPERATOR REFERENCIA
-split (binario) about_Split
-join (binario) about_Join
-is -isnot -as about_Type_Operators
-eq -ne -gt -ge -lt -le about_Comparison_Operators
-like -notlike about_Comparison_Operators
-match -notmatch about_Comparison_Operators
-in -notIn about_Comparison_Operators
-contains -notContains about_Comparison_Operators
-replace about_Comparison_Operators

La lista se reanuda aquí con los siguientes operadores en orden de precedencia:

OPERATOR REFERENCIA
-band -bnot -bor -bxor -shr -shl about_Arithmetic_Operators
-and -or -xor about_Logical_Operators

Los siguientes elementos no son operadores true. Forman parte de la sintaxis de comandos de PowerShell, no de la sintaxis de expresión. La asignación siempre es la última acción que se produce.

SINTAXIS REFERENCIA
. (dot-source) about_Operators
& (llamada) about_Operators
? <if-true> : <if-false> (Operador Ternary) about_Operators
?? (operador de fusión null) about_Operators
| (operador de canalización) about_Operators
> >> 2> 2>> 2>&1 about_Redirection
&& || (operadores de cadena de canalización) about_Operators
= += -= *= /= %= ??= about_Assignment_Operators

Ejemplos

Los dos comandos siguientes muestran los operadores aritméticos y el efecto de usar paréntesis para forzar a PowerShell a evaluar primero la parte delimitada de la expresión.

PS> 2 + 3 * 4
14

PS> (2 + 3) * 4
20

En el ejemplo siguiente se obtienen los archivos de texto de solo lectura del directorio local y se guardan en la $read_only variable .

$read_only = Get-ChildItem *.txt | Where-Object {$_.isReadOnly}

Es equivalente al ejemplo siguiente.

$read_only = ( Get-ChildItem *.txt | Where-Object {$_.isReadOnly} )

Dado que el operador de canalización (|) tiene una prioridad mayor que el operador de asignación (=), los archivos que obtiene el Get-ChildItemWhere-Object cmdlet se envían al cmdlet para filtrar antes de asignarlos a la $read_only variable.

En el ejemplo siguiente se muestra que el operador de índice tiene prioridad sobre el operador de conversión.

Esta expresión crea una matriz de tres cadenas. A continuación, usa el operador de índice con un valor de 0 para seleccionar el primer objeto de la matriz, que es la primera cadena. Por último, convierte el objeto seleccionado como una cadena. En este caso, la conversión no tiene ningún efecto.

PS> [string]@('Windows','PowerShell','2.0')[0]
Windows

Esta expresión usa paréntesis para forzar que se produzca la operación de conversión antes de la selección del índice. Como resultado, toda la matriz se convierte como una cadena (única). A continuación, el operador de índice selecciona el primer elemento de la matriz de cadenas, que es el primer carácter.

PS> ([string]@('Windows','PowerShell','2.0'))[0]
W

En el ejemplo siguiente, dado que el -gt operador (mayor que) tiene una prioridad mayor que el -and operador (AND lógico), el resultado de la expresión es FALSE.

PS> 2 -gt 4 -and 1
False

Es equivalente a la siguiente expresión.

PS> (2 -gt 4) -and 1
False

Si el operador -and tenía mayor prioridad, la respuesta sería TRUE.

PS> 2 -gt (4 -and 1)
True

Sin embargo, en este ejemplo se muestra un principio importante de la administración de la precedencia del operador. Cuando una expresión es difícil de interpretar, use paréntesis para forzar el orden de evaluación, incluso cuando fuerza la prioridad del operador predeterminado. Los paréntesis hacen que sus intenciones sean claras para las personas que leen y mantienen sus scripts.

Consulte también