7. Expresiones

2025-01-12

Nota editorial

Importante

La especificación de lenguaje de Windows PowerShell 3.0 se publicó en diciembre de 2012 y se basa en Windows PowerShell 3.0. Esta especificación no refleja el estado actual de PowerShell. No hay ningún plan para actualizar esta documentación para reflejar el estado actual. Esta documentación se presenta aquí para obtener referencia histórica.

El documento de especificación está disponible como un documento de Microsoft Word del Centro de descarga de Microsoft en: https://www.microsoft.com/download/details.aspx?id=36389 Ese documento de Word se ha convertido para su presentación aquí en Microsoft Learn. Durante la conversión, se han realizado algunos cambios editoriales para dar cabida al formato de la plataforma Docs. Se han corregido algunos errores tipográficos y menores.

Sintaxis:

expression:
    primary-expression
    bitwise-expression
    logical-expression
    comparison-expression
    additive-expression
    multiplicative-expression

dash: one of
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

dashdash:
    dash dash

Descripción:

Una expresión es una secuencia de operadores y operandos que designa un método, una función, una ubicación grabable o un valor; especifica el cálculo de un valor; produce uno o varios efectos secundarios; o realiza alguna combinación. Por ejemplo

El literal 123 es una expresión que designa el valor int 123.
La expresión 1,2,3,4 designa el objeto de matriz de 4 elementos que tiene los valores mostrados.
La expresión 10.4 * $a especifica un cálculo.
La expresión $a++ produce un efecto secundario.
La expresión $a[$i--] = $b[++$j] realiza una combinación de estas cosas.

Excepto como se especifica para algunos operadores, el orden de evaluación de términos en una expresión y el orden en el que se producen los efectos secundarios no se especifican. Entre los ejemplos de comportamiento no especificado se incluyen los siguientes: $i++ + $i, $i + --$iy $w[$j++] = $v[$j].

Una implementación de PowerShell puede proporcionar compatibilidad con tipos definidos por el usuario y esos tipos pueden tener operaciones definidas en ellos. Todos los detalles de estos tipos y operaciones se definen en la implementación.

Una expresión de nivel superior es una que no forma parte de alguna expresión más grande. Si una expresión de nivel superior contiene un operador de efecto secundario, el valor de esa expresión no se escribe en la canalización; de lo contrario, sí que se escribe. Consulte §7.1.1 para obtener una explicación detallada de esto.

Normalmente, una expresión que designa una colección ([§4§4]) se enumera en sus elementos constituyentes cuando se usa el valor de esa expresión. Sin embargo, esto no es el caso cuando la expresión es una invocación de cmdlet. Por ejemplo

$x = 10,20,30
$a = $($x; 99)                     # $a.Length is 4

$x = New-Object 'int[]' 3
$a = $($x; 99)                     # equivalent, $a.Length is 4

$a = $(New-Object 'int[]' 3; 99)   # $a.Length is 2

En los dos primeros usos del operador $(...), la expresión que designa la colección es la variable $x, que se enumera, lo que da como resultado tres valores int, además del int 99. Sin embargo, en el tercer caso, la expresión es una llamada directa a un cmdlet, por lo que el resultado no se enumera y $a es una matriz de dos elementos, int[3] y int.

Si PowerShell no define una operación, se inspecciona el tipo del valor designado por el operando izquierdo para ver si tiene un método op_<operation> correspondiente.

7.1 Expresiones principales

Sintaxis:

primary-expression:
    value
    member-access
    element-access
    invocation-expression
    post-increment-expression
    post-decrement-expression

value:
    parenthesized-expression
    sub-expression
    array-expression
    script-block-expression
    hash-literal-expression
    literal
    type-literal
    variable

7.1.1 Paréntesis de agrupación

Sintaxis:

Sugerencia

La notación ~opt~ en las definiciones de sintaxis indica que la entidad léxica es opcional en la sintaxis.

parenthesized-expression:
    ( new-lines~opt~ pipeline new-lines~opt~ )

Descripción:

Una expresión entre paréntesis es una de expresión principal cuyo tipo y valor son los mismos que los de la expresión sin paréntesis. Si la expresión designa una variable, la expresión entre paréntesis designa esa misma variable. Por ejemplo, $x.m y ($x).m son equivalentes.

Se pueden usar paréntesis de agrupación en una expresión para documentar la precedencia y la asociatividad predeterminadas dentro de esa expresión. También se pueden usar para invalidar esa precedencia y asociatividad predeterminadas. Por ejemplo

4 + 6 * 2    # 16
4 + (6 * 2)  # 16 document default precedence
(4 + 6) * 2  # 20 override default precedence

Normalmente, los paréntesis de agrupación en el nivel superior son redundantes. Sin embargo, eso no siempre es el caso. Tenga en cuenta el ejemplo siguiente:

2,4,6       # Length 3; values 2,4,6
(2,4),6     # Length 2; values [object[]],int

En el segundo caso, los paréntesis cambian la semántica, lo que da como resultado una matriz cuyos dos elementos son una matriz de 2 ints y el valor escalar int 6.

Esta es otra excepción:

23.5/2.4          # pipeline gets 9.79166666666667
$a = 1234 * 3.5   # value not written to pipeline
$a                # pipeline gets 4319

En el primer y tercer caso, el valor del resultado se escribe en la canalización. Pero aunque se evalúa la expresión en el segundo caso, el resultado no se escribe en la canalización debido a la presencia del operador de efecto secundario = en el nivel superior. (La eliminación de la parte de $a = permite escribir el valor, ya que * no es un operador de efecto secundario).

Para impedir que un valor de cualquier expresión que no contenga efectos secundarios de nivel superior se escriba en la canalización, descártelo explícitamente, tal como se muestra a continuación:

# None of these value are written to pipeline
[void](23.5/2.4)
[void]$a
$null = $a
$a > $null

Para escribir en la canalización el valor de cualquier expresión que contenga efectos secundarios de nivel superior, encierre esa expresión entre paréntesis, como se indica a continuación:

($a = 1234 * 3.5) # pipeline gets 4319

Por lo tanto, los paréntesis de agrupación en este caso no son redundantes.

En el ejemplo siguiente, tenemos la sustitución de variables (§2.3.5.2) que tiene lugar en un literal de cadena:

">$($a = -23)<"    # value not written to pipeline, get ><
">$(($a = -23))<"  # pipeline gets >-23<

En el primer caso, los paréntesis representan los delimitadores de una subexpresión que no agrupan paréntesis y, como la expresión de nivel superior contiene un operador de efecto secundario, el valor de la expresión no se escribe en la canalización. Por supuesto, los caracteres > y < todavía están escritos). Si se agregan paréntesis de agrupación, como se muestra en el segundo caso, la escritura está habilitada.

Los ejemplos siguientes contienen operadores de efecto secundario de nivel superior:

$a = $b = 0      # value not written to pipeline
$a = ($b = 0)    # value not written to pipeline
($a = ($b = 0))  # pipeline gets 0

++$a             # value not written to pipeline
(++$b)           # pipeline gets 1

$a--             # value not written to pipeline
($b--)           # pipeline gets 1

El uso de paréntesis de agrupación en torno a una expresión que no contiene efectos secundarios de nivel superior hace que esos paréntesis sean redundantes. Por ejemplo;

$a      # pipeline gets 0
($a)    # no side effect, so () redundant

Considere el ejemplo siguiente que tiene dos efectos secundarios, ninguno de los cuales está en el nivel superior:

12.6 + ($a = 10 - ++$b) # pipeline gets 21.6.

El resultado se escribe en la canalización, ya que la expresión de nivel superior no tiene efectos secundarios.

7.1.2 Acceso a miembros

Sintaxis:

member-access:
    primary-expression . new-line~opt~ member-name
    primary-expression :: new-line~opt~ member-name

Tenga en cuenta que no se permite ningún espacio en blanco después de expresión principal.

Descripción:

El operador . se usa para seleccionar un miembro de instancia de un objeto o una clave de un Hashtable. El operando izquierdo debe designar un objeto y el operando derecho debe designar un miembro de instancia accesible.

El operando derecho designa un miembro de instancia accesible dentro del tipo del objeto designado por el operando izquierdo o, si el operando izquierdo designa una matriz, el operando derecho designa miembros de instancia accesibles dentro de cada elemento de la matriz.

No se permite el espacio en blanco antes del operador ..

Este operador es asociativo a la izquierda.

El operador :: se usa para seleccionar un miembro estático de un tipo determinado. El operando izquierdo debe designar un tipo y el operando derecho debe designar un miembro estático accesible dentro de ese tipo.

No se permite el espacio en blanco antes del operador ::.

Este operador es asociativo a la izquierda.

Si el operando derecho designa una ubicación grabable dentro del tipo del objeto designado por el operando izquierdo, la expresión completa designa una ubicación grabable.

Ejemplos:

$a = 10, 20, 30
$a.Length                    # get instance property

(10, 20, 30).Length

$property = "Length"
$a.$property                 # property name is a variable

$h1 = @{ FirstName = "James"; LastName = "Anderson"; IDNum = 123
}
$h1.FirstName                # designates the key FirstName
$h1.Keys                     # gets the collection of keys

[int]::MinValue              # get static property
[double]::PositiveInfinity   # get static property
$property = "MinValue"
[long]::$property            # property name is a variable

foreach ($t in [byte], [int], [long]) {
    $t::MaxValue             # get static property
}

$a = @{ID = 1 }, @{ID = 2 }, @{ID = 3 }
$a.ID                        # get ID from each element in the array

7.1.3 Expresiones de invocación

Sintaxis:

invocation-expression:
    primary-expression . new-line~opt~ member-name argument-list
    primary-expression :: new-line~opt~ member-name argument-list

argument-list:
    ( argument-expression-list~opt~ new-lines~opt~ )

Tenga en cuenta que no se permite ningún espacio en blanco después de la expresión principal .

Descripción:

Un invocation-expression llama al método designado por primary-expression.member-name o primary-expression::member-name. Los paréntesis de argument-list contienen una lista posiblemente vacía separada por comas de expresiones que designan los argumentos cuyos valores se pasan al método . Antes de llamar al método , los argumentos se evalúan y convierten según las reglas de §6, si es necesario, para que coincidan con los tipos esperados por el método . El orden de evaluación de primary-expression.member-name, primary-expression::member-namey los argumentos no se especifican.

Este operador es asociativo a la izquierda.

El tipo del resultado de una invocation-expression es un method-designator (sección 4.5.24).

Ejemplos:

[math]::Sqrt(2.0)            # call method with argument 2.0
[char]::IsUpper("a")         # call method
$b = "abc#$%XYZabc"
$b.ToUpper()                 # call instance method

[math]::Sqrt(2)              # convert 2 to 2.0 and call method
[math]::Sqrt(2D)             # convert 2D to 2.0 and call method
[math]::Sqrt($true)          # convert $true to 1.0 and call method
[math]::Sqrt("20")           # convert "20" to 20 and call method

$a = [math]::Sqrt            # get method descriptor for Sqrt
$a.Invoke(2.0)               # call Sqrt via the descriptor
$a = [math]::("Sq"+"rt")     # get method descriptor for Sqrt
$a.Invoke(2.0)               # call Sqrt via the descriptor
$a = [char]::ToLower         # get method descriptor for ToLower
$a.Invoke("X")               # call ToLower via the descriptor

Acceso a elementos 7.1.4

Sintaxis:

element-access:
    primary-expression [ new-lines~opt~ expression new-lines~opt~ ]

Descripción:

No debe haber ningún espacio en blanco entre de expresión principal y el corchete izquierdo ([).

7.1.4.1 Subíndice de una matriz

Descripción:

Las matrices se describen en detalle en §9. Si la expresión es una matriz unidimensional, consulte §7.1.4.5.

Cuando la expresión primaria designa una matriz unidimensional A, el operador [] devuelve el elemento ubicado en A[0 + expression] después de que el valor de la expresión se haya convertido en int. El resultado tiene el tipo de elemento de la matriz que se está subindizando. Si la expresión es negativa, A[expression] designa el elemento ubicado en el A[A.Length + expression].

Cuando la expresión principal designa una matriz bidimensional B, el operador [] devuelve el elemento ubicado en B[0 + row,0 + column], después de que se hayan convertido los componentes de la fila y la columna de la expresión (que se especifican como una lista separada por comas) en int. El resultado tiene el tipo de elemento de la matriz que se está subindizando. A diferencia de una matriz 1 dimensional, las posiciones negativas no tienen ningún significado especial.

Cuando expresión principal designa una matriz de tres o más dimensiones, las reglas de las matrices 2 dimensionales se aplican y las posiciones de dimensión se especifican como una lista separada por comas de valores.

Si se intenta un acceso de lectura en un elemento no existente, el resultado es $null. Es un error escribir en un elemento no existente.

Para una expresión de subíndice de matriz multidimensional, no se especifica el orden de evaluación de las expresiones de posición de dimensión. Por ejemplo, dada una matriz 3 dimensional $a, no se especifica el comportamiento de $a[$i++,$i,++$i].

Si expresión es una matriz, consulte §7.1.4.5.

Este operador es asociativo a la izquierda.

Ejemplos:

$a = [int[]](10,20,30) # [int[]], Length 3
$a[1] # returns int 20
$a[20] # no such position, returns $null
$a[-1] # returns int 30, i.e., $a[$a.Length-1]
$a[2] = 5 # changes int 30 to int 5
$a[20] = 5 # implementation-defined behavior

$a = New-Object 'double[,]' 3,2
$a[0,0] = 10.5 # changes 0.0 to 10.5
$a[0,0]++ # changes 10.5 to 10.6

$list = ("red",$true,10),20,(1.2, "yes")
$list[2][1] # returns string "yes"

$a = @{ A = 10 },@{ B = $true },@{ C = 123.45 }
$a[1]["B"] # $a[1] is a Hashtable, where B is a key

$a = "red","green"
$a[1][4] # returns string "n" from string in $a[1]

Si se intenta un acceso de escritura a un elemento no existente, se produce una excepción IndexOutOfRange.

7.1.4.2 Suscripción de una cadena

Descripción:

Cuando primary-expression designa una cadena S, el operador [] devuelve el carácter ubicado en la posición de base cero que indica expression, como un char. Si expresión es mayor o igual que la longitud de esa cadena, el resultado es $null. Si expression es negativo, S[expression] designa el elemento ubicado en S[S.Length + expression].

Ejemplos:

$s = "Hello"   # string, Length 5, positions 0-4
$c = $s[1]     # returns "e" as a string
$c = $s[20]    # no such position, returns $null
$c = $s[-1]    # returns "o", i.e., $s[$s.Length-1]

7.1.4.3 Subíndice de una tabla hash

Descripción:

Cuando primary-expression designa una tabla hash, el operador [] devuelve los valores asociados a las claves que designa expression. El tipo de expression no está restringido.

Cuando expresión es un nombre de clave único, el resultado es el valor asociado y tiene ese tipo, a menos que no exista dicha clave, en cuyo caso, el resultado es $null. Si $null se usa como clave, se define la implementación del comportamiento. Si la expresión es un arreglo de nombres de clave, consulte §7.1.4.5.

Si expresión es una matriz, consulte §7.1.4.5.

Ejemplos:

$h1 = @{ FirstName = "James"; LastName = "Anderson"; IDNum = 123 }
$h1['FirstName']     # the value associated with key FirstName
$h1['BirthDate']     # no such key, returns $null

$h1 = @{ 10 = "James"; 20.5 = "Anderson"; $true = 123 }
$h1[10]              # returns value "James" using key 10
$h1[20.5]            # returns value "Anderson" using key 20.5
$h1[$true]           # returns value 123 using key $true

Cuando expresión es un nombre de clave único, si $null se usa como el único valor para subindizar una tabla hash, se genera una excepción NullArrayIndex.

7.1.4.4 Suscripción de un documento XML

Descripción:

Cuando expresión primaria designa un objeto de tipo xml, expresión se convierte en cadena, si es necesario, y el operador [] devuelve el primer elemento secundario con el nombre que especifica expresión. El tipo de expresión debe ser una cadena de texto. La implementación define el tipo del resultado. El resultado se puede subindizar para devolver su primer elemento secundario. Si no existe ningún elemento secundario con el nombre especificado por expresión, el resultado es $null. El resultado no designa una ubicación grabable.

Ejemplos:

$x = [xml]@"
<Name>
<FirstName>Mary</FirstName>
<LastName>King</LastName>
</Name>
"@

$x['Name']                # refers to the element Name
$x['Name']['FirstName']   # refers to the element FirstName within Name
$x['FirstName']           # No such child element at the top level, result is $null

El tipo del resultado es System.Xml.XmlElement o System.String.

7.1.4.5 Generación de segmentos de matriz

Cuando expresión primaria designa un objeto de un tipo enumerable (sección 4) o una tabla hash, y expresión es una matriz unidimensional, el resultado es un segmento de matriz (sección 9.9) que contiene los elementos de expresión primaria que designan los elementos de expresión.

En el caso de una tabla Hash, el segmento de matriz contiene los valores asociados a las claves proporcionadas, a menos que no exista dicha clave, en cuyo caso, el elemento correspondiente es $null. Si $null se usa como cualquier nombre clave, se define la implementación del comportamiento.

Ejemplos:

$a = [int[]](30,40,50,60,70,80,90)
$a[1,3,5]                 # slice has Length 3, value 40,60,80
$a[,5]                    # slice with Length 1
$a[@()]                   # slice with Length 0
$a[-1..-3]                # slice with Length 3, value 90,80,70
$a = New-Object 'int[,]' 3,2
$a[0,0] = 10; $a[0,1] = 20; $a[1,0] = 30
$a[1,1] = 40; $a[2,0] = 50; $a[2,1] = 60
$a[(0,1),(1,0)]           # slice with Length 2, value 20,30, parens needed
$h1 = @{ FirstName = "James"; LastName = "Anderson"; IDNum = 123 }
$h1['FirstName']          # the value associated with key FirstName
$h1['BirthDate']          # no such key, returns $null
$h1['FirstName','IDNum']  # returns [object[]], Length 2 (James/123)
$h1['FirstName','xxx']    # returns [object[]], Length 2 (James/$null)
$h1[$null,'IDNum']        # returns [object[]], Length 2 ($null/123)

Windows PowerShell: cuando expresión es una colección de dos o más nombres de clave, si $null se usa como cualquier nombre de clave, esa clave se omite y no tiene ningún elemento correspondiente en la matriz resultante.

7.1.5 Operadores de incremento y decremento postfijos

Sintaxis:

post-increment-expression:
    primary-expression ++

post-decrement-expression:
    primary-expression dashdash

Descripción:

La expresión primaria debe designar una ubicación grabable que tenga un valor de tipo numérico (sección 4) o el valor $null. Si el valor designado por el operando es $null, ese valor se convierte en tipo int y valor cero antes de evaluar el operador. El tipo del valor designado por primary-expression puede cambiar cuando se almacena el resultado. Consulte §7.11 para obtener una explicación del cambio de tipo a través de la asignación.

El resultado generado por el operador postfijo ++ es el valor designado por el operando. Después de obtener ese resultado, el valor designado por el operando se incrementa en 1 del tipo adecuado. El tipo del resultado de la expresión E++ es el mismo que para el resultado de la expresión E + 1 (§7.7).

El resultado generado por el operador postfijo -- es el valor designado por el operando. Después de obtener ese resultado, el valor designado por el operando se disminuye en 1 del tipo adecuado. El tipo del resultado de la expresión E-- es el mismo que para el resultado de la expresión E - 1 (§7.7).

Estos operadores son asociativos a la izquierda.

Ejemplos:

$i = 0                # $i = 0
$i++                  # $i is incremented by 1
$j = $i--             # $j takes on the value of $i before the decrement

$a = 1,2,3
$b = 9,8,7
$i = 0
$j = 1
$b[$j--] = $a[$i++]   # $b[1] takes on the value of $a[0], then $j is
                      # decremented, $i incremented

$i = 2147483647       # $i holds a value of type int
$i++                  # $i now holds a value of type double because
                      # 2147483648 is too big to fit in type int

[int]$k = 0           # $k is constrained to int
$k = [int]::MaxValue  # $k is set to 2147483647
$k++                  # 2147483648 is too big to fit, imp-def behavior

$x = $null            # target is unconstrained, $null goes to [int]0
$x++                  # value treated as int, 0->1

Operador 7.1.6 $(...)

Sintaxis:

sub-expression:
    $( new-lines~opt~ statement-list~opt~ new-lines~opt~ )

Descripción:

Si se omite la lista de declaraciones , el resultado es $null. De lo contrario, se evalúa lista de instrucciones. Los objetos escritos en la canalización como parte de la evaluación se recopilan en una matriz unidimensional sin restricciones, en orden. Si la matriz de objetos recopilados está vacía, el resultado es $null. Si la matriz de objetos recopilados contiene un único elemento, el resultado es ese elemento; De lo contrario, el resultado es la matriz 1 dimensional sin restricciones de los resultados recopilados.

Ejemplos:

$j = 20
$($i = 10) # pipeline gets nothing
$(($i = 10)) # pipeline gets int 10
$($i = 10; $j) # pipeline gets int 20
$(($i = 10); $j) # pipeline gets [object[]](10,20)
$(($i = 10); ++$j) # pipeline gets int 10
$(($i = 10); (++$j)) # pipeline gets [object[]](10,22)
$($i = 10; ++$j) # pipeline gets nothing
$(2,4,6) # pipeline gets [object[]](2,4,6)

Operador 7.1.7 @(...)

Sintaxis:

array-expression:
    @( new-lines~opt~ statement-list~opt~ new-lines~opt~ )

Descripción:

Si se omite la lista de declaraciones , el resultado es una matriz unidimensional sin restricciones de longitud cero. De lo contrario, se evalúa lista de instrucciones y los objetos escritos en la canalización como parte de la evaluación se recopilan en una matriz unidimensional sin restricciones, en orden. El resultado es la matriz 1 dimensional sin restricciones (posiblemente vacía).

Ejemplos:

$j = 20
@($i = 10)             # 10 not written to pipeline, result is array of 0
@(($i = 10))           # pipeline gets 10, result is array of 1
@($i = 10; $j)         # 10 not written to pipeline, result is array of 1
@(($i = 10); $j)       # pipeline gets 10, result is array of 2
@(($i = 10); ++$j)     # pipeline gets 10, result is array of 1
@(($i = 10); (++$j))   # pipeline gets both values, result is array of 2
@($i = 10; ++$j)       # pipeline gets nothing, result is array of 0

$a = @(2,4,6)          # result is array of 3
@($a)                  # result is the same array of 3
@(@($a))               # result is the same array of 3

7.1.8 Expresión de bloque de script

Sintaxis:

script-block-expression:
    { new-lines~opt~ script-block new-lines~opt~ }

script-block:
    param-block~opt~ statement-terminators~opt~ script-block-body~opt~

script-block-body:
    named-block-list
    statement-list

Descripción:

param-block se describe en la sección 8.10.9. named-block-list se describe en la sección 8.10.7.

Un bloque de script es un bloque sin nombre compuesto por instrucciones que pueden usarse como una sola unidad. Los bloques de script se pueden usar para invocar un bloque de código como si fuera un único comando o se pueden asignar a variables que se pueden ejecutar.

Se ejecuta la lista de bloques nombrados o la lista de instrucciones , y el tipo y los valores del resultado son el tipo y los valores de los resultados de esos conjuntos de instrucciones.

Una expresión de bloque de script tiene el tipo scriptblock (sección 4.3.7).

Si se omite param-block, cualquier argumento pasado al bloque de scripts está disponible a través de $args (§8.10.1).

Durante el enlace de parámetros, un bloque de script se puede pasar como un objeto de bloque de script o como resultado después de evaluar el bloque de script. Consulte §6.17 para obtener más información.

7.1.9 Expresión literal hash

Sintaxis:

hash-literal-expression:
    @{ new-lines~opt~ hash-literal-body~opt~ new-lines~opt~ }

hash-literal-body:
    hash-entry
    hash-literal-body statement-terminators hash-entry

hash-entry:
    key-expression = new-lines~opt~ statement

key-expression:
    simple-name
    unary-expression

statement-terminators:
    statement-terminator
    statement-terminators statement-terminator

statement-terminator:
    ;
    new-line-character

Descripción:

Una expresión literal hash se usa para crear una tabla hash (sección 10) de cero o más elementos, cada uno de los cuales es un par clave-valor.

La clave puede tener cualquier tipo excepto el tipo NULL. Los valores asociados pueden tener cualquier tipo, incluido el tipo NULL, y cada uno de esos valores puede ser cualquier expresión que designe el valor deseado, incluido $null.

El orden de los pares clave-valor no es significativo.

Ejemplos:

$h1 = @{ FirstName = "James"; LastName = "Anderson"; IDNum = 123 }
$last = "Anderson"; $IDNum = 120
$h2 = @{ FirstName = "James"; LastName = $last; IDNum = $IDNum + 3 }
$h3 = @{ }
$h4 = @{ 10 = "James"; 20.5 = "Anderson"; $true = 123 }

que crea dos tablas Hash, $h1 y $h2, cada una que contiene tres pares clave-valor y una tercera, $h3, que está vacía. El $h4 hashtable tiene claves de varios tipos.

7.1.10 Expresión literal de tipo

Sintaxis:

type-literal:
    [ type-spec ]

type-spec:
    array-type-name new-lines~opt~ dimension~opt~ ]
    generic-type-name new-lines~opt~ generic-type-arguments ]
    type-name

dimension:
    ,
    dimension ,

generic-type-arguments:
    type-spec new-lines~opt~
    generic-type-arguments , new-lines~opt~ type-spec

array-type-name:
    type-name [

generic-type-name:
    type-name [

Descripción:

Un literal de tipo se representa en una implementación mediante algún tipo subyacente no especificado. Como resultado, un nombre de tipo es un sinónimo de su tipo subyacente.

Los literales de tipo se usan en varios contextos:

Especificar una conversión explícita (§6, §7.2.9)
Creación de una matriz restringida de tipos (§9.4)
Acceso a los miembros estáticos de un objeto (§7.1.2)
Especificar una restricción de tipo en una variable (§5.3) o un parámetro de función (§8.10.2)

Ejemplos:

[int].IsPrimitive        # $true
[Object[]].FullName      # "System.Object[]"
[int[,,]].GetArrayRank() # 3

Un tipo de pila genérico (§4.4) especializado para contener cadenas podría escribirse como [Stack[string]]y un tipo de diccionario genérico especializado para contener claves de int con valores de cadena asociados podría escribirse como [Dictionary[int,string]].

El tipo de un literal de tipo es System.Type. El nombre completo del tipo Stack[string] sugerido anteriormente es System.Collections.Generic.Stack[int]. El nombre completo del tipo Dictionary[int,string] sugerido anteriormente es System.Collections.Generic.Dictionary[int,string].

7.2 Operadores unarios

Sintaxis:

unary-expression:
    primary-expression
    expression-with-unary-operator

expression-with-unary-operator:
    , new-lines~opt~ unary-expression
    -not new-lines~opt~ unary-expression
    ! new-lines~opt~ unary-expression
    -bnot new-lines~opt~ unary-expression
    + new-lines~opt~ unary-expression
    dash new-lines~opt~ unary-expression
    pre-increment-expression
    pre-decrement-expression
    cast-expression
    -split new-lines~opt~ unary-expression
    -join new-lines~opt~ unary-expression

pre-increment-expression:
    ++ new-lines~opt~ unary-expression

pre-decrement-expression:
    dashdash new-lines~opt~ unary-expression

dash: one of
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

cast-expression:
    type-literal unary-expression

dashdash:
    dash dash

7.2.1 Operador de coma unario

Descripción:

El operador de coma (,) crea una matriz unidimensional sin restricciones que tiene un elemento, cuyo tipo y valor son de expresión unaria.

Este operador es asociativo a la derecha.

Ejemplos:

$a = ,10         # create an unconstrained array of 1 element, $a[0],
                 # which has type int

$a = ,(10,"red") # create an unconstrained array of 1 element,
$a[0],
                 # which is an unconstrained array of 2 elements,
                 # $a[0][0] an int, and $a[0][1] a string

$a = ,,10        # create an unconstrained array of 1 element, which is
                 # an unconstrained array of 1 element, which is an int
                 # $a[0][0] is the int. Contrast this with @(@(10))

7.2.2 Operador NOT lógico

Sintaxis:

logical-not-operator:
    dash not

dash: one of
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

Descripción:

El operador -not convierte el valor designado por la expresión unaria al tipo bool (§6.2), si es necesario, y genera un resultado de ese tipo. Si el valor de expresión unaria es True, el resultado es False, y viceversa. El operador ! es una ortografía alternativa para -not.

Este operador es asociativo a la derecha.

Ejemplos:

-not $true         # False
-not -not $false   # False
-not 0             # True
-not 1.23          # False
!"xyz"             # False

7.2.3 Operador NOT bit a bit

Sintaxis:

bitwise-not-operator:
    dash bnot

dash: one of
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

Descripción:

El operador -bnot convierte el valor designado por unary-expression en un tipo entero (§6.4), si es necesario. Si el valor convertido se puede representar en el tipo int ese es el tipo de resultado. De lo contrario, si el valor convertido se puede representar en el tipo long ese es el tipo de resultado. De lo contrario, la expresión tiene un formato incorrecto. El valor resultante es el complemento de uno del valor convertido.

Este operador es asociativo a la derecha.

Ejemplos:

-bnot $true         # int with value 0xFFFFFFFE
-bnot 10            # int with value 0xFFFFFFF5
-bnot 2147483648.1  # long with value 0xFFFFFFFF7FFFFFFF
-bnot $null         # int with value 0xFFFFFFFF
-bnot "0xabc"       # int with value 0xFFFFF543

7.2.4 Unary plus

Descripción:

Una expresión del formulario + unary-expression se trata como si se escribiera como 0 + unary-expression (§7.7). El 0 literal entero tiene el tipo int.

Este operador es asociativo a la derecha.

Ejemplos:

+123L         # type long, value 123
+0.12340D     # type decimal, value 0.12340
+"0xabc"      # type int, value 2748

7.2.5 Resta unaria

Descripción:

Una expresión del formulario - unary-expression se trata como si se escribiera como 0 - unary-expression (§7.7). El literal entero 0 tiene el tipo int. El operador menos puede ser cualquiera de los caracteres de guion de enumerados en la sección 7.2.

Este operador es asociativo a la derecha.

Ejemplos:

-$true     # type int, value -1
-123L      # type long, value -123
-0.12340D  # type decimal, value -0.12340

7.2.6 Operadores de incremento y decremento prefijos

Descripción:

La unary-expression debe designar una ubicación grabable que tenga un valor de tipo numérico (sección 4) o el valor$null. Si el valor que designa su expresión unaria es $null, el valor de expresión unaria se convierte al tipo int y al valor cero antes de que se evalúe el operador.

Nota

El tipo del valor designado por expresión-unaria puede cambiar cuando se almacena el resultado. Consulte §7.11 para obtener una explicación del cambio de tipo a través de la asignación.

Para el prefijo de operador de incremento ++, el valor de unary-expression se incrementa en 1 del tipo adecuado. El resultado es el nuevo valor después de que se haya realizado el incremento. La expresión ++E es equivalente a E += 1 (§7.11.2).

Para el prefijo de operador de decremento --, el valor de unary-expression se reduce en 1 del tipo adecuado. El resultado es el nuevo valor después de que se haya producido un decremento. La expresión --E es equivalente a E -= 1 (§7.11.2). El operador de decremento de prefijo puede ser cualquiera de los patrones que coinciden con el patrón de dashdash en la sección 7.2.

Estos operadores son asociativos a la derecha.

Ejemplos:

$i = 0                # $i = 0
++$i                  # $i is incremented by 1
$j = --$i             # $i is decremented then $j takes on the value of $i

$a = 1,2,3
$b = 9,8,7
$i = 0;
$j = 1
$b[--$j] = $a[++$i]   # $j is # decremented, $i incremented, then $b[0]
                      # takes on the value of $a[1]

$i = 2147483647       # $i holds a value of type int
++$i                  # $i now holds a value of type double because
                      # 2147483648 is too big to fit in type int

[int]$k = 0           # $k is constrained to int
$k = [int]::MinValue  # $k is set to -2147483648
--$k                  # -2147483649 is too small to fit, imp-def behavior

$x = $null            # target is unconstrained, $null goes to [int]0
--$x                  # value treated as int, 0 becomes -1

7.2.7 Operador unario -join

Sintaxis:

join-operator:
    dash join

dash: one of
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

Descripción:

El operador unario -join genera una cadena que es la concatenación del valor de uno o varios objetos designados por unary-expression . (Se puede insertar un separador mediante la versión binaria de este operador (§7.8.4.4).)

unary-expression puede ser un valor escalar o una colección.

Ejemplos:

-join (10, 20, 30)             # result is "102030"
-join (123, $false, 19.34e17)  # result is "123False1.934E+18"
-join 12345                    # result is "12345"
-join $null                    # result is ""

7.2.8 Operador unario -split

Sintaxis:

split-operator:
    dash split

dash: one of
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

Descripción:

El operador unario -split divide una o varias cadenas designadas por expresión unaria, devolviendo sus subpartes en una matriz unidimensional restringida de cadenas. Trata cualquier grupo contiguo de caracteres de espacio en blanco como delimitador entre subpartes sucesivas. Se puede especificar una cadena delimitadora explícita mediante la versión binaria de este operador (§7.8.4.5) o sus dos variantes (§7.8).

El texto delimitador no se incluye en las cadenas resultantes. Se omite el espacio en blanco inicial y final de la cadena de entrada. Una cadena de entrada vacía o que contiene espacios en blanco solo da como resultado una matriz de una cadena, que está vacía.

unary-expression puede designar un valor escalar o una matriz de cadenas.

Ejemplos:

-split " red`tblue`ngreen " # 3 strings: "red", "blue", "green"
-split ("yes no", "up down") # 4 strings: "yes", "no", "up", "down"
-split " " # 1 (empty) string

7.2.9 Operador de conversión

Descripción:

Este operador convierte explícitamente (§6) el valor designado por la expresión unaria al tipo designado por el literal de tipo (§7.1.10). Si literal de tipo es distinto de void, el tipo del resultado es el tipo con nombre y el valor es el de después de la conversión. Si literal de tipo es void, no se escribe ningún objeto en la canalización y no hay ningún resultado.

Cuando se convierte una expresión de cualquier tipo en ese mismo tipo, el tipo y el valor resultantes son los del tipo y valor de la expresión unaria .

Este operador es asociativo a la derecha.

Ejemplos:

[bool]-10        # a bool with value True
[int]-10.70D     # a decimal with value -10
[int]10.7        # an int with value 11
[long]"+2.3e+3"  # a long with value 2300
[char[]]"Hello"  # an array of 5 char with values H, e, l, l, and o.

Operador de coma binario 7.3

Sintaxis:

array-literal-expression:
    unary-expression , new-lines~opt~ array-literal-expression

Descripción:

El operador de coma binaria crea una matriz 1 dimensional cuyos elementos son los valores designados por sus operandos, en orden léxico. La matriz tiene un tipo sin restricciones.

Ejemplos:

2,4,6                    # Length 3; values 2,4,6
(2,4),6                  # Length 2; values [object[]],int
(2,4,6),12,(2..4)        # Length 3; [object[]],int,[object[]]
2,4,6,"red",$null,$true  # Length 6

La adición de paréntesis de agrupación a determinadas expresiones de coma binarias no documenta la precedencia predeterminada; en su lugar, cambia el resultado.

7.4 Operador de rango

Sintaxis:

range-expression:
    unary-expression .. new-lines~opt~ unary-expression

Descripción:

Una range-expression crea una matriz unidimensional sin restricciones cuyos elementos son los valores de la secuencia int que especifican los límites de intervalo. Los valores designados por los operandos se convierten en int, si es necesario (§6.4). El operando que designa el valor inferior después de la conversión es el límite inferior, mientras que el operando que designa el valor superior después de la conversión es el límite superior. Ambos límites pueden ser los mismos, en cuyo caso la matriz resultante tiene longitud 1. Si el operando izquierdo designa el límite inferior, la secuencia está en orden ascendente. Si el operando izquierdo designa el límite superior, la secuencia está en orden descendente.

Conceptualmente, este operador es un atajo para la secuencia correspondiente de operadores binarios de coma. Por ejemplo, el intervalo 5..8 también se puede generar mediante 5,6,7,8. Sin embargo, si se necesita una secuencia ascendente o descendente sin tener una matriz, una implementación puede evitar generar una matriz real. Por ejemplo, en foreach ($i in 1..5) { ... }, no es necesario crear ninguna matriz.

Se puede usar una expresión de rango para especificar un segmento de matriz (sección 9.9).

Ejemplos:

1..10        # ascending range 1..10
-495..-500   # descending range -495..-500
16..16       # sequence of 1

$x = 1.5
$x..5.40D    # ascending range 2..5

$true..3     # ascending range 1..3
-2..$null    # ascending range -2..0
0xf..0xa     # descending range 15..10

Operador de formato 7.5

Sintaxis:

format-expression:
    format-specification-string format-operator new-lines~opt~ range-expression

format-operator:
    dash f

dash:
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

Descripción:

Una expresión de formato da formato a uno o varios valores designados por una expresión de rango de acuerdo con una cadena de especificación de formato designada por una expresión de formato . Las posiciones de los valores designados por la expresión de rango se numeran a partir de cero y aumentan en orden léxico. El resultado tiene el tipo string.

Una cadena de especificación de formato puede contener cero o más especificaciones de formato cada una con el formato siguiente:

{N [ ,M ][ : FormatString ]}

N representa una posición de valor de expresión de rango (obligatorio), M representa el ancho de pantalla mínimo (opcional) y FormatString indica el formato (opcional). Si el ancho de un valor con formato supera el ancho especificado, el ancho se aumenta en consecuencia. Los valores cuyas posiciones no se referencian en FormatString se omiten después de ser evaluados para cualquier efecto secundario. Si N hace referencia a una posición inexistente, el comportamiento dependerá de la implementación. El valor de tipo $null y void tiene el formato de cadenas vacías. Las matrices tienen el formato de subexpresión (sección 7.1.6). Para incluir los caracteres { y } en una especificación de formato sin que se interpreten como delimitadores de formato, escríbalos como {{ y }}, respectivamente.

Para obtener una definición completa de las especificaciones de formato, vea el tipo System.IFormattable en el Informe técnico TR/84 de la Ecma.

Ejemplos:

"__{0,3}__" -f 5                         # __ 5__
"__{0,-3}__" -f 5                        # __5 __
"__{0,3:000}__" -f 5                     # __005__
"__{0,5:0.00}__" -f 5.0                  # __ 5.00__
"__{0:C}__" -f 1234567.888               # __$1,234,567.89__
"__{0:C}__" -f -1234.56                  # __($1,234.56)__
"__{0,12:e2}__" -f 123.456e2             # __ 1.23e+004__
"__{0,-12:p}__" -f -0.252                # __-25.20 % __

$i = 5; $j = 3
"__{0} + {1} <= {2}__" -f $i,$j,($i+$j)  # __5 + 3 <= 8__

$format = "__0x{0:X8}__"
$format -f 65535                         # __0x0000FFFF__

En una especificación de formato, si N se refiere a una posición inexistente, se genera un FormatError.

7.6 Operadores multiplicativos

Sintaxis:

multiplicative-expression:
    multiplicative-expression * new-lines~opt~ format-expression
    multiplicative-expression / new-lines~opt~ format-expression
    multiplicative-expression % new-lines~opt~ format-expression

7.6.1 Multiplicación

Descripción:

El resultado del operador de multiplicación * es el producto de los valores designados por los dos operandos después de aplicar las conversiones aritméticas habituales (§6.15).

Este operador es asociativo a la izquierda.

Ejemplos:

12 * -10L      # long result -120
-10.300D * 12  # decimal result -123.600
10.6 * 12      # double result 127.2
12 * "0xabc"   # int result 32976

7.6.2 Replicación de cadenas

Descripción:

Cuando el operando izquierdo designa una cadena, el operador binario * crea una nueva cadena que contiene la designada por el operando izquierdo replicada el número de veces designado por el valor del operando derecho después de convertirlo al tipo entero (§6.4).

Este operador es asociativo a la izquierda.

Ejemplos:

"red" * "3"       # string replicated 3 times
"red" * 4         # string replicated 4 times
"red" * 0         # results in an empty string
"red" * 2.3450D   # string replicated twice
"red" * 2.7       # string replicated 3 times

7.6.3 Replicación de matriz

Descripción:

Cuando el operando izquierdo designa una matriz, el operador binario * crea una nueva matriz 1 dimensional sin restricciones que contiene el valor designado por el operando izquierdo replicado el número de veces designado por el valor del operando derecho como convertido al tipo entero (§6.4). Un recuento de replicación de cero da como resultado una matriz de longitud 1. Si el operando izquierdo designa una matriz multidimensional, se aplana (sección 9.12) antes de usarse.

Este operador es asociativo a la izquierda.

Ejemplos:

$a = [int[]](10,20)              # [int[]], Length 2*1
$a * "3"                         # [object[]], Length 2*3
$a * 4                           # [object[]], Length 2*4
$a * 0                           # [object[]], Length 2*0
$a * 2.3450D                     # [object[]], Length 2*2
$a * 2.7                         # [object[]], Length 2*3
(New-Object 'float[,]' 2,3) * 2  # [object[]], Length 2*2

7.6.4 División

Descripción:

El resultado del operador de división / es el cociente cuando el valor designado por el operando izquierdo se divide por el valor designado por el operando derecho después de las conversiones aritméticas habituales (§6.15) se han aplicado.

Si se intenta realizar un entero o una división decimal por cero, se genera un error de terminación definido por la implementación.

Este operador es asociativo a la izquierda.

Ejemplos:

10/-10      # int result -1
12/-10      # double result -1.2
12/-10D     # decimal result 1.2
12/10.6     # double result 1.13207547169811
12/"0xabc"  # double result 0.00436681222707424

Si se intenta realizar una división de un número entero o decimal por cero, se genera una excepción RuntimeException.

7.6.5 Resto

Descripción:

El resultado del operador de resto % es el resto cuando el valor designado por el operando izquierdo se divide por el valor designado por el operando derecho después de las conversiones aritméticas habituales (§6.15) se han aplicado.

Si se intenta realizar un entero o una división decimal por cero, se genera un error de terminación definido por la implementación.

Ejemplos:

10 % 3          # int result 1
10.0 % 0.3      # double result 0.1
10.00D % "0x4"  # decimal result 2.00

Si se intenta realizar una división entera o decimal por cero, se genera una excepción RuntimeException.

7.7 Operadores de suma

Sintaxis:

additive-expression:
    primary-expression + new-lines~opt~ expression
    primary-expression dash new-lines~opt~ expression

dash: one of
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

7.7.1 Adición

Descripción:

El resultado del operador de suma + es la suma de los valores designados por los dos operandos después de que se hayan aplicado las conversiones aritméticas habituales (§6.15).

Este operador es asociativo a la izquierda.

Ejemplos:

12 + -10L       # long result 2
-10.300D + 12   # decimal result 1.700
10.6 + 12       # double result 22.6
12 + "0xabc"    # int result 2760

7.7.2 Concatenación de cadenas

Descripción:

Cuando el operando izquierdo designa una cadena, el operador binario + crea una nueva cadena que contiene el valor designado por el operando izquierdo, seguido inmediatamente por el o los valores designados por el operando derecho, convertidos al tipo cadena (§6.8).

Este operador es asociativo a la izquierda.

Ejemplos:

"red" + "blue"      # "redblue"
"red" + "123"       # "red123"
"red" + 123         # "red123"
"red" + 123.456e+5  # "red12345600"
"red" + (20,30,40)  # "red20 30 40"

7.7.3 Concatenación de matrices

Descripción:

Cuando el operando izquierdo designa una matriz, el operador binario + crea una nueva matriz 1 dimensional sin restricciones que contiene los elementos designados por el operando izquierdo seguido inmediatamente de los valores designados por el operando derecho. Las matrices multidimensionales presentes en cualquiera de los operandos se aplanan (sección 9.12) antes de usarse.

Este operador es asociativo a la izquierda.

Ejemplos:

$a = [int[]](10,20)               # [int[]], Length 2
$a + "red"                        # [object[]], Length 3
$a + 12.5,$true                   # [object[]], Length 4
$a + (New-Object 'float[,]' 2,3)  # [object[]], Length 8
(New-Object 'float[,]' 2,3) + $a  # [object[]], Length 8

7.7.4 Concatenación de tabla hash

Descripción:

Cuando ambos operandos designan Hashtables, el operador binario + crea una nueva tabla Hash que contiene los elementos designados por el operando izquierdo seguidos inmediatamente por los elementos designados por el operando derecho.

Si las tablas hash contienen la misma clave, se genera un error de terminación definido por la implementación.

Este operador es asociativo a la izquierda.

Ejemplos:

$h1 = @{ FirstName = "James"; LastName = "Anderson" }
$h2 = @{ Dept = "Personnel" }
$h3 = $h1 + $h2      # new Hashtable, Count = 3

Si las tablas hash contienen la misma clave, se genera una excepción de tipo BadOperatorArgument.

7.7.5 Resta

Descripción:

El resultado del operador de resta - es la diferencia cuando el valor designado por el operando derecho se resta del valor designado por el operando izquierdo, después de aplicar las conversiones aritméticas habituales (§6.15). El operador menos puede ser cualquiera de los caracteres de guion de enumerados en la sección 7.7.

Este operador es asociativo a la izquierda.

Ejemplos:

12 - -10L      # long result 22
-10.300D - 12  # decimal result -22.300
10.6 - 12      # double result -1.4
12 - "0xabc"   # int result -2736

7.8 Operadores de comparación

Sintaxis:

comparison-expression:
    primary-expression comparison-operator new-lines~opt~ expression

comparison-operator:
    equality-operator
    relational-operator
    containment-operator
    type-operator
    like-operator
    match-operator

Descripción:

El tipo del valor designado por el operando izquierdo determina cómo se convierte el valor designado por el operando derecho (§6), si es necesario, antes de que se realice la comparación.

Algunos operadores de comparación tienen dos variantes, una que distingue mayúsculas de minúsculas (-c<operator>) y otra que no distingue mayúsculas de minúsculas (-i<operator>). La versión de -<operator> es equivalente a -i<operator>. La distinción entre mayúsculas y minúsculas solo es significativa con las comparaciones de valores de tipo cadena. En contextos de comparación que no son de cadena, las dos variantes se comportan igual.

Estos operadores son asociativos a la izquierda.

7.8.1 Operadores relacionales y igualdad

Sintaxis:

equality-operator: one of
    dash eq     dash ceq    dash ieq
    dash ne     dash cne    dash ine

dash:
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

relational-operator: one of
    dash lt     dash clt    dash ilt
    dash le     dash cle    dash ile
    dash gt     dash cgt    dash igt
    dash ge     dash cge    dash ige

Descripción:

Hay dos operadores de igualdad: igualdad (-eq) y desigualdad (-ne); y cuatro operadores relacionales: menor que (-lt), menor o igual que (-le), mayor que (-gt) y mayor que o igual que (-ge). Cada una de estas tiene dos variantes (§7.8).

Para que dos cadenas se comparen como iguales, deben tener la misma longitud y contenido, y la misma estructura de mayúsculas y minúsculas, si procede.

Si el valor designado por el operando izquierdo no es una colección, el resultado tiene el tipo bool. De lo contrario, el resultado es una matriz 1 dimensional sin restricciones posiblemente vacía que contiene los elementos de la colección que prueban True en comparación con el valor designado por el operando derecho.

Ejemplos:

10 -eq "010"           # True, int comparison
"010" -eq 10           # False, string comparison
"RED" -eq "Red"        # True, case-insensitive comparison
"RED" -ceq "Red"       # False, case-sensitive comparison
"ab" -lt "abc"         # True

10,20,30,20,10 -ne 20  # 10,30,10, Length 3
10,20,30,20,10 -eq 40  # Length 0
10,20,30,20,10 -ne 40  # 10,20,30,20,10, Length 5
10,20,30,20,10 -gt 25  # 30, Length 1
0,1,30 -ne $true       # 0,30, Length 2
0,"00" -eq "0"         # 0 (int), Length 1

7.8.2 Operadores de contención

Sintaxis:

containment-operator: one of
    dash contains       dash ccontains      dash icontains
    dash notcontains    dash cnotcontains   dash inotcontains
    dash in             dash cin            dash iin
    dash notin          dash cnotin         dash inotin

dash:
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

Descripción:

Hay cuatro operadores de contención: contiene (-contains), no contiene (-notcontains), en (-in) y no en (-notin). Cada una de estas tiene dos variantes (§7.8).

Los operadores de contención devuelven un resultado de tipo bool que indica si se produce un valor (o no se produce) al menos una vez en los elementos de una matriz. Con -contains y -notcontains, el valor se designa mediante el operando derecho y el operando izquierdo designa la matriz. Con -in y -notin, se invierten los operandos. El valor se designa mediante el operando izquierdo y el operando derecho designa la matriz.

Para los fines de estos operadores, si el operando de matriz tiene un valor escalar, el valor escalar se trata como una matriz de un elemento.

Ejemplos:

10,20,30,20,10 -contains 20     # True
10,20,30,20,10 -contains 42.9   # False
10,20,30 -contains "10"         # True
"10",20,30 -contains 10         # True
"010",20,30 -contains 10        # False
10,20,30,20,10 -notcontains 15  # True
"Red",20,30 -ccontains "RED"    # False

7.8.3 Operadores de prueba y conversión de tipos

Sintaxis:

type-operator: one of
    dash is
    dash as

dash:
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

Descripción:

El operador de tipo -is comprueba si el valor designado por el operando izquierdo tiene el tipo o se deriva de un tipo que tiene el tipo designado por el operando derecho. El operando derecho debe designar un tipo o un valor que se pueda convertir en un tipo (por ejemplo, una cadena que asigne un nombre a un tipo). El tipo del resultado es bool. El operador de tipo -isnot devuelve la negación lógica del formulario de -is correspondiente.

El operador de tipo -as intenta convertir el valor designado por el operando izquierdo al tipo designado por el operando derecho. El operando derecho debe designar un tipo o un valor que se pueda convertir en un tipo (por ejemplo, una cadena que asigne un nombre a un tipo). Si se produce un error en la conversión, se devuelve $null; De lo contrario, se devuelve el valor convertido y el tipo de valor devuelto de ese resultado es el tipo en tiempo de ejecución del valor convertido.

Ejemplos:

$a = 10            # value 10 has type int
$a -is [int]       # True

$t = [int]
$a -isnot $t       # False
$a -is "int"       # True
$a -isnot [double] # True

$x = [int[]](10,20)
$x -is [int[]]     # True

$a = "abcd"        # string is derived from object
$a -is [object]    # True

$x = [double]
foreach ($t in [int],$x,[decimal],"string") {
    $b = (10.60D -as $t) * 2  # results in int 22, double 21.2
}                             # decimal 21.20, and string "10.6010.60"

7.8.4 Operadores de coincidencia de patrones y manipulación de texto

7.8.4.1 Operadores de -like y -notlike

Sintaxis:

like-operator: one of
    dash like       dash clike      dash ilike
    dash notlike    dash cnotlike   dash inotlike

dash:
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

Descripción:

Si el operando izquierdo no designa una colección, el resultado tiene el tipo bool. De lo contrario, el resultado es una matriz 1 dimensional sin restricciones posiblemente vacía que contiene los elementos de la colección que prueban True en comparación con el valor designado por el operando derecho. El operando derecho puede designar una cadena que contenga expresiones con caracteres comodín (sección 3.15). Estos operadores tienen dos variantes (§7.8).

Ejemplos:

"Hello" -like "h*"                   # True, starts with h
"Hello" -clike "h*"                  # False, does not start with lowercase h
"Hello" -like "*l*"                  # True, has an l in it somewhere
"Hello" -like "??l"                  # False, no length match

"-abc" -like "[-xz]*"                # True, - is not a range separator
"#$%\^&" -notlike "*[A-Za-z]"        # True, does not end with alphabetic character
"He" -like "h[aeiou]?*"              # False, need at least 3 characters
"When" -like "*[?]"                  # False, ? is not a wildcard character
"When?" -like "*[?]"                 # True, ? is not a wildcard character

"abc","abbcde","abcgh" -like "abc*"  # object[2], values
"abc" and "abcgh"

7.8.4.2 Operadores de -match y -notmatch

Sintaxis:

match-operator: one of
    dash match      dash cmatch     dash imatch
    dash notmatch   dash cnotmatch  dash inotmatch

dash:
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

Descripción:

Si el operando izquierdo no designa una colección, el resultado tiene el tipo bool y, si ese resultado es $true, los elementos de la Hashtable $matches se establecen en las cadenas que coinciden (o no coinciden) con el valor designado por el operando derecho. De lo contrario, el resultado es una matriz unidimensional sin restricciones posiblemente vacía que contiene los elementos de la colección que prueban True en comparación con el valor que designa el operando derecho y $matches no se establece. El operando derecho puede designar una cadena que contenga expresiones regulares (§3.16), en cuyo caso se conoce como patrón . Estos operadores tienen dos variantes (§7.8).

Estos operadores admiten submatches (§7.8.4.6).

Ejemplos:

"Hello" -match ".l"                    # True, $matches key/value is 0/"el"
"Hello" -match '\^h.*o$'               # True, $matches key/value is
0/"Hello"
"Hello" -cmatch '\^h.*o$'              # False, $matches not set
"abc\^ef" -match ".\\\^e"              # True, $matches key/value is 0/"c\^e"

"abc" -notmatch "[A-Za-z]"             # False
"abc" -match "[\^A-Za-z]"              # False
"He" -match "h[aeiou]."                # False, need at least 3 characters
"abc","abbcde","abcgh" -match "abc.*"  # Length is 2, values "abc", "abcgh"

7.8.4.3 Operador -replace

Sintaxis:

binary-replace-operator: one of
    dash replace    dash creplace   dash ireplace

dash:
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

Descripción:

El operador -replace permite el reemplazo de texto en una o varias cadenas designadas por el operando izquierdo mediante los valores designados por el operando derecho. Este operador tiene dos variantes (§7.8). El operando derecho tiene uno de los formatos siguientes:

La cadena que se va a localizar, que puede contener expresiones regulares (sección 3.16). En este caso, la cadena de reemplazo es implícitamente "".
Matriz de 2 objetos que contienen la cadena que se va a ubicar, seguida de la cadena de reemplazo.

Si el operando izquierdo designa una cadena, el resultado es de tipo cadena. Si el operando izquierdo designa una matriz dimensional de cadena, el resultado es una matriz 1 dimensional sin restricciones, cuya longitud es la misma que para la matriz del operando izquierdo, que contiene las cadenas de entrada después de que se haya completado el reemplazo.

Este operador admite submatches (§7.8.4.6).

Ejemplos:

"Analogous","an apple" -replace "a","*"      # "*n*logous","*n *pple"
"Analogous" -creplace "[aeiou]","?"          # "An?l?g??s"
"Analogous","an apple" -replace '\^a',"%%A"  # "%%Analogous","%%An apple"
"Analogous" -replace "[aeiou]",'$&$&'        # "AAnaaloogoouus"

7.8.4.4 Operador de -join binario

Sintaxis:

binary-join-operator: one of
    dash join

dash:
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

Descripción:

El operador binario -join genera una cadena que es la concatenación del valor de uno o varios objetos designados por el operando izquierdo tras ser convertidos a cadena (§6.7), si es necesario. La cadena designada por el operando derecho se usa para separar los valores (posiblemente vacíos) de la cadena resultante.

El operando izquierdo puede ser un valor escalar o una colección.

Ejemplos:

(10, 20, 30) -join "\|"    # result is "10\|20\|30"
12345 -join ","            # result is "12345", no separator needed
($null,$null) -join "<->"  # result is "<->", two zero-length values

7.8.4.5 Operador de -split binario

Sintaxis:

binary-split-operator: one of
    dash split      dash csplit     dash isplit

dash:
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

Descripción:

El operador binario -split divide una o varias cadenas designadas por el operando izquierdo, devolviendo sus subpartes en una matriz 1 dimensional restringida de cadena. Este operador tiene dos variantes (§7.8). El operando izquierdo puede designar un valor escalar o una matriz de cadenas. El operando derecho tiene uno de los formatos siguientes:

Una cadena de delimitador.
Una matriz de 2 objetos que contiene una cadena de delimitador seguida de un recuento de divisiones numéricas.
Una matriz de 3 objetos que contiene una cadena de delimitador, un recuento de divisiones numéricas y una cadena de opciones.
Un bloque de script
Una matriz de 2 objetos que contiene un bloque de script seguido de un recuento de divisiones numéricas.

La cadena delimitador puede contener expresiones regulares (§3.16). Se usa para buscar subpartes con las cadenas de entrada. El delimitador no se incluye en las cadenas resultantes. Si el operando izquierdo designa una cadena vacía, que da como resultado un elemento de cadena vacío. Si la cadena delimitadora es vacía, se encuentra en cada posición de carácter de las cadenas de entrada.

De forma predeterminada, todas las subpartes de las cadenas de entrada se colocan en el resultado como elementos independientes; sin embargo, el recuento de divisiones se puede usar para modificar este comportamiento. Si ese recuento es negativo, cero o mayor o igual que el número de subpartes de una cadena de entrada, cada subparte entra en un elemento independiente. Si ese recuento es menor que el número de subpartes de la cadena de entrada, hay elementos count en el resultado, con el elemento final que contiene todas las subpartes más allá de las primeras subpartes count - 1.

Una cadena de opciones contiene cero o más nombres de opción con cada par adyacente separado por una coma. Se omiten los espacios en blanco iniciales, finales e insertados. Los nombres de opción pueden estar en cualquier orden y distinguen mayúsculas de minúsculas.

Si una cadena de opciones contiene el nombre de la opción SimpleMatch, también puede contener el nombre de la opción IgnoreCase. Si una cadena de opciones contiene el nombre de la opción RegexMatch o no contiene RegexMatch o SimpleMatch, puede contener cualquier nombre de opción excepto SimpleMatch. Pero no debe contener Multiline ni Singleline.

Este es el conjunto de nombres de opción:

Opción 2	Descripción
CultureInvariant	Omite las diferencias culturales en el lenguaje al evaluar el delimitador.
ExplicitCapture	Omite los grupos de coincidencias sin nombre para que solo se devuelvan grupos de captura explícitos en la lista de resultados.
IgnoreCase	Fuerza la coincidencia sin distinguir mayúsculas de minúsculas, aunque se utilice `-csplit`.
IgnorePatternWhitespace	Omite los espacios en blanco sin escape y los comentarios marcados con el signo de número (`#`).
Multilínea	Este modo reconoce el inicio y el final de las líneas y cadenas. El modo predeterminado es singleline.
RegexMatch	Use la coincidencia de expresiones regulares para evaluar el delimitador. Este es el valor predeterminado.
SimpleMatch	Use una comparación de cadenas sencilla al evaluar el delimitador.
Línea única	Este modo solo reconoce el inicio y el final de las cadenas. Es el modo predeterminado.

El bloque de script (sección 7.1.8) especifica las reglas para determinar el delimitador y debe evaluarse para el tipo booleano.

Ejemplos:

"one,forty two,," -split ","              # 5 strings: "one" "forty two" "" ""

"abc","de" -split ""                      # 9 strings: "" "a" "b" "c" "" "" "d" "e" ""

"ab,cd","1,5,7,8" -split ",", 2           # 4 strings: "ab" "cd" "1" "5,7,8"

"10X20x30" -csplit "X", 0, "SimpleMatch"  # 2 strings: "10" "20x30"

"analogous" -split "[AEIOU]", 0, "RegexMatch, IgnoreCase"
                                          # 6 strings: "" "n" "l" "g" "" "s"

"analogous" -split { $_ -eq "a" -or $_ -eq "o" }, 4
                                          # 4 strings: "" "n" "l" "gous"

7.8.4.6 Subcoincidencias

El patrón que coincide con -match, -notmatchy -replace puede contener subpartes (denominadas submatches) delimitadas por paréntesis. Tenga en cuenta el ejemplo siguiente:

"red" -match "red"

El resultado es $true y la clave 0 de $matches contiene "rojo", esa parte de la cadena designada por el operando izquierdo que coincide exactamente con el patrón designado por el operando derecho.

En el siguiente ejemplo, todo el patrón forma una subcoincidencia.

"red" -match "(red)"

Como antes, la clave 0 contiene "red", pero la clave 1 también contiene "red", que es esa parte de la cadena que designa el operando izquierdo y que coincide exactamente con la subcoincidencia.

Tenga en cuenta lo siguiente, más complejo, patrón:

"red" -match "((r)e)(d)"

Este patrón permite subcoincidencias de "re", "r", "d" o "red".

De nuevo, la clave 0 contiene "rojo". La clave 1 contiene "re", la clave 2 contiene "r" y la clave 3 contiene "d". Los pares clave-valor están en orden coincidente de izquierda a derecha en el patrón, con coincidencias de cadena más largas anteriores a las más cortas.

En el caso de -replace, el texto de reemplazo puede acceder a las subcoincidencias mediante nombres con el formato $n, donde la primera coincidencia es $1, la segunda es $3, y así sucesivamente. Por ejemplo

"Monday morning" -replace '(Monday|Tuesday) (morning|afternoon|evening)','the $2 of $1'

La cadena resultante es "la mañana del lunes".

En lugar de que las claves en $matches sean índices que comienzan desde cero, las subcoincidencias se pueden denominar utilizando el formato ?<*name*>. Por ejemplo, "((r)e)(d)" se puede escribir con tres subcoincidencias con nombre, m1, m2 y m3, tal como se muestra a continuación: "(?<m1>(?<m2>r)e)(?<m3>d)".

7.8.5 Operadores de desplazamiento

Sintaxis:

shift-operator: one of
    dash shl
    dash shr

dash:
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

Descripción:

El operador shift left (-shl) y el operador shift right (-shr) convierten el valor diseñado por el operando izquierdo en un tipo entero y el valor designado por el operando derecho a int, si es necesario, utilizando las conversiones aritméticas habituales (§6.15).

El operador de desplazamiento a la izquierda desplaza el operando izquierdo a la izquierda un número de bits calculados, tal como se describe a continuación. Las posiciones de bits vacías de orden bajo se establecen en cero.

El operador de desplazamiento a la derecha desplaza el operando izquierdo a la derecha un número de bits calculados, tal como se describe a continuación. Los bits de orden bajo del operando izquierdo se descartan; los bits restantes se desplazan a la derecha. Cuando el operando izquierdo es un valor con signo, las posiciones de bits vacías de orden alto se establecen en cero si el operando izquierdo no es negativo y se establece en uno si el operando izquierdo es negativo. Cuando el operando izquierdo es un valor sin signo, las posiciones de bits vacías de orden alto se establecen en cero.

Cuando el operando izquierdo tiene el tipo int, el recuento de desplazamiento se determina por los cinco bits de orden inferior del operando derecho. Cuando el operando derecho tiene el tipo long, el recuento de desplazamientos lo da el orden inferior de seis bits del operando derecho.

Ejemplos:

0x0408 -shl 1             # int with value 0x0810
0x0408 -shr 3             # int with value 0x0081
0x100000000 -shr 0xfff81  # long with value 0x80000000

7.9 Operadores bit a bit

Sintaxis:

bitwise-expression:
    unary-expression -band new-lines~opt~ unary-expression
    unary-expression -bor new-lines~opt~ unary-expression
    unary-expression -bxor new-lines~opt~ unary-expression

Descripción:

El operador AND bit a bit -band, el operador OR bit a bit -bory el operador bit a bit XOR -bxor convierten los valores designados por sus operandos en tipos enteros, si es necesario, mediante las conversiones aritméticas habituales (§6.15). Después de la conversión, si ambos valores tienen tipo int, este será el tipo del resultado. De lo contrario, si ambos valores tienen el tipo long, ese es el tipo del resultado. Si un valor tiene el tipo int y el otro tiene el tipo long, el tipo del resultado es largo. De lo contrario, la expresión tiene un formato incorrecto. El resultado es el operador AND bit a bit, OR bit a bit o XOR bit a bit, respectivamente, de los valores del operando posiblemente convertidos.

Estos operadores son asociativos a la izquierda. Son conmutantes si ninguno de los operandos contiene un efecto secundario.

Ejemplos:

0x0F0F -band 0xFE    # int with value 0xE
0x0F0F -band 0xFEL   # long with value 0xE
0x0F0F -band 14.6    # long with value 0xF

0x0F0F -bor 0xFE     # int with value 0xFFF
0x0F0F -bor 0xFEL    # long with value 0xFFF
0x0F0F -bor 14.40D   # long with value 0xF0F

0x0F0F -bxor 0xFE    # int with value 0xFF1
0x0F0F -bxor 0xFEL   # long with value 0xFF1
0x0F0F -bxor 14.40D  # long with value 0xF01
0x0F0F -bxor 14.6    # long with value 0xF00

7.10 Operadores lógicos

Sintaxis:

logical-expression:
    unary-expression -and new-lines~opt~ unary-expression
    unary-expression -or new-lines~opt~ unary-expression
    unary-expression -xor new-lines~opt~ unary-expression

Descripción:

El operador AND lógico -and convierte los valores designados por sus operandos en bool, si es necesario (§6.2). El resultado es el AND lógico de los valores del operando posiblemente convertido y tiene el tipo bool. Si el operando izquierdo se evalúa como False, no se evalúa el operando derecho.

El operador OR lógico -or convierte los valores designados por sus operandos en bool, si es necesario (§6.2). El resultado es el operador OR lógico de los valores del operando posiblemente convertidos y tiene el tipo bool. Si el operando izquierdo se evalúa como True, no se evalúa el operando derecho.

El operador XOR lógico -xor convierte los valores designados por sus operandos en bool (§6.2). El resultado es el XOR lógico de los valores de operando posiblemente convertidos y tiene el tipo bool.

Estos operadores son asociativos a la izquierda.

Ejemplos:

$j = 10
$k = 20
($j -gt 5) -and (++$k -lt 15)   # True -and False -> False
($j -gt 5) -and ($k -le 21)     # True -and True -> True
($j++ -gt 5) -and ($j -le 10)   # True -and False -> False
($j -eq 5) -and (++$k -gt 15)   # False -and True -> False

$j = 10
$k = 20
($j++ -gt 5) -or (++$k -lt 15)  # True -or False -> True
($j -eq 10) -or ($k -gt 15)     # False -or True -> True
($j -eq 10) -or (++$k -le 20)   # False -or False -> False

$j = 10
$k = 20
($j++ -gt 5) -xor (++$k -lt 15) # True -xor False -> True
($j -eq 10) -xor ($k -gt 15)    # False -xor True -> True
($j -gt 10) -xor (++$k -le 25)  # True -xor True -> False

7.11 Operadores de asignación

Sintaxis:

assignment-expression:
    expression assignment-operator statement

assignment-operator: *one of
    =   dash =   +=   *=   /=   %=

Descripción:

Un operador de asignación almacena un valor en la ubicación escribible designada por la expresión . Para obtener una explicación del assignment-operator= , consulte la sección 7.11.1. Para obtener una explicación de todos los demás operadores de asignación, consulte §7.11.2.

Una expresión de asignación tiene el valor que designa expresión después de que se haya realizado la asignación, pero esa expresión de asignación no designa por sí misma una ubicación grabable. Si expresión está restringida por tipos (§5.3), el tipo usado en esa restricción es el tipo del resultado; De lo contrario, el tipo del resultado es el tipo después de aplicar las conversiones aritméticas habituales (§6.15).

Este operador es asociativo a la derecha.

7.11.1 Asignación simple

Descripción:

En la asignación simple (=), el valor que designa la instrucción reemplaza el valor almacenado en la ubicación grabable que designa la expresión. Sin embargo, si expresión designa una clave inexistente en un Hashtable, esa clave se agrega al Hashtable con un valor asociado del valor designado por la declaración .

Como se muestra en la gramática, la expresión puede designar una lista separada por comas de ubicaciones escribibles. Esto se conoce como asignación múltiple. La instrucción designa una lista de uno o varios valores separados por comas. Las comas de cualquiera de las dos listas de operandos forman parte de la sintaxis de varias asignaciones y no representan el operador de coma binario. Los valores se extraen de la lista designada por la instrucción y se almacenan, en orden léxico, en la ubicación escribible correspondiente designada por la expresión . Si la lista que designa la instrucción tiene menos valores que los que hay en ubicaciones grabables en la expresión, el exceso de ubicaciones toma el valor $null. Si la lista que designa la instrucción tiene más valores que ubicaciones grabables de expresión, todas las ubicaciones de expresión más a la derecha toman el valor de instrucción correspondiente y la ubicación de expresión más a la derecha se convierte en una matriz unidimensional sin restricciones, con todos los valores de instrucción restantes como elementos.

Para las instrucciones que tienen valores (sección 8.1.2), instrucción puede ser una instrucción.

Ejemplos:

$a = 20; $b = $a + 12L             # $b has type long, value 22
$hypot = [Math]::Sqrt(3*3 + 4*4)   # type double, value 5
$a = $b = $c = 10.20D              # all have type decimal, value 10.20
$a = (10,20,30),(1,2)              # type [object[]], Length 2
[int]$x = 10.6                     # type int, value 11
[long]$x = "0xabc"                 # type long, value 0xabc
$a = [float]                       # value type literal [float]
$i,$j,$k = 10,"red",$true          # $i is 10, $j is "red", $k is True
$i,$j = 10,"red",$true             # $i is 10, $j is [object[]], Length 2
$i,$j = (10,"red"),$true           # $i is [object[]], Length 2, $j is True
$i,$j,$k = 10                      # $i is 10, $j is $null, $k is $null

$h = @{}
[int] $h.Lower, [int] $h.Upper = -split "10 100"

$h1 = @{ FirstName = "James"; LastName = "Anderson"; IDNum = 123 }
$h1.Dept = "Finance"               # adds element Finance
$h1["City"] = "New York"           # adds element City

[int]$Variable:v = 123.456         # v takes on the value 123
${E:output.txt} = "a"              # write text to the given file
$Env:MyPath = "x:\data\file.txt"   # define the environment variable
$Function:F = { param ($a, $b) "Hello there, $a, $b" }
F 10 "red"                         # define and invoke a function
function Demo { "Hi there from inside Demo" }
$Alias:A = "Demo"                  # create alias for function Demo
A                                  # invoke function Demo via the alias

7.11.2 Asignación compuesta

Descripción:

Una asignación compuesta tiene el formato E1 op= E2 y es equivalente a la expresión de asignación simple E1 = E1 op (E2) salvo que, en el caso de asignación compuesta, la expresión E1 solo se evalúa una vez. Si expresión está restringida por tipos (sección 5.3), el tipo usado en esa restricción es el tipo del resultado. De lo contrario, el tipo del resultado lo determina op. Para *=, consulte §7.6.1, §7.6.2, §7.6.3; para /=, consulte §7.6.4; para %=, consulte §7.6.5; para +=, consulte §7.7.1, §7.7.2, §7.7.3; para -=, consulte §7.7.5.

Nota

Un operando que designa un valor sin restricciones de tipo numérico puede tener su tipo cambiado por un operador de asignación cuando se almacena el resultado.

Ejemplos:

$a = 1234; $a *= (3 + 2)  # type is int, value is 1234 * (3 + 2)
$b = 10,20,30             # $b[1] has type int, value 20
$b[1] /= 6                # $b[1] has type double, value 3.33...

$i = 0
$b = 10,20,30
$b[++$i] += 2             # side effect evaluated only once

[int]$Variable:v = 10     # v takes on the value 10
$Variable:v -= 3          # 3 is subtracted from v

${E:output.txt} = "a"     # write text to the given file
${E:output.txt} += "b"    # append text to the file giving ab
${E:output.txt} *= 4      # replicate ab 4 times giving abababab

7.12 Operadores de redireccionamiento

Sintaxis:

pipeline:
    expression redirections~opt~ pipeline-tail~opt~
    command verbatim-command-argument~opt~ pipeline-tail~opt~

redirections:
    redirection
    redirections redirection

redirection:
    merging-redirection-operator
    file-redirection-operator redirected-file-name

redirected-file-name:
    command-argument
    primary-expression

file-redirection-operator: one of
    >   >>   2>   2>>   3>   3>>   4>   4>>
    5>  5>>  6>   6>>   >    >>    <

merging-redirection-operator: one of
    >&1   2>&1   3>&1   4>&1   5>&1   6>&1
    >&2   1>&2   3>&2   4>&2   5>&2   6>&2

Descripción:

El operador de redireccionamiento > toma la salida estándar de la canalización y la redirige a la ubicación que designa nombre de archivo redirigido, lo que sobrescribe el contenido actual de esa ubicación.

El operador de redireccionamiento >> toma la salida estándar de la canalización y la redirige a la ubicación que designa nombre de archivo redirigido, anexando al contenido actual de esa ubicación, si lo hubiera. Si esa ubicación no existe, se crea.

El operador de redireccionamiento con formato n> toma la salida del flujo n de la canalización y la redirige a la ubicación que designa nombre de archivo redirigido, lo que sobrescribe el contenido actual de esa ubicación.

El operador de redireccionamiento con formato n>> toma la salida del flujo n de la canalización y la redirige a la ubicación que designa nombre de archivo redirigido, anexando al contenido actual de esa ubicación, si lo hubiera. Si esa ubicación no existe, se crea.

El operador de redireccionamiento con formato m>&n escribe la salida del flujo m en la misma ubicación que e flujo n.

A continuación se muestran los flujos válidos:

Transmisión	Descripción
1	Flujo de salida estándar
2	Flujo de salida de error
3	Flujo de salida de advertencia
4	Flujo de salida detallada
5	Flujo de salida de depuración
*	Salida estándar, salida de error, salida de advertencia, salida detallada y flujos de salida de depuración

Los operadores de redireccionamiento 1>&2, 6>, 6>> y < están reservados para su uso futuro.

Si en la salida el valor de nombre de archivo redirigido es $null, la salida se descarta.

Normalmente, el valor de una expresión que contiene un efecto secundario de nivel superior no se escribe en la canalización a menos que esa expresión esté entre paréntesis. Sin embargo, si dicha expresión es el operando izquierdo de un operador que redirige la salida estándar, se escribe el valor.

Ejemplos:

$i = 200                       # pipeline gets nothing
$i                             # pipeline gets result
$i > output1.txt               # result redirected to named file
++$i >> output1.txt            # result appended to named file
type file1.txt 2> error1.txt   # error output redirected to named file
type file2.txt 2>> error1.txt  # error output appended to named file
dir -Verbose 4> verbose1.txt   # verbose output redirected to named file

# Send all output to output2.txt
dir -Verbose -Debug -WarningAction Continue *> output2.txt

# error output redirected to named file, verbose output redirected
# to the same location as error output
dir -Verbose 4>&2 2> error2.txt

Compartir a través de

7. Expresiones

Nota editorial

7.1 Expresiones principales

7.1.1 Paréntesis de agrupación

7.1.2 Acceso a miembros

7.1.3 Expresiones de invocación

Acceso a elementos 7.1.4

7.1.4.1 Subíndice de una matriz

7.1.4.2 Suscripción de una cadena

7.1.4.3 Subíndice de una tabla hash

7.1.4.4 Suscripción de un documento XML

7.1.4.5 Generación de segmentos de matriz

7.1.5 Operadores de incremento y decremento postfijos

Operador 7.1.6 $(...)

Operador 7.1.7 @(...)

7.1.8 Expresión de bloque de script

7.1.9 Expresión literal hash

7.1.10 Expresión literal de tipo

7.2 Operadores unarios

7.2.1 Operador de coma unario

7.2.2 Operador NOT lógico

7.2.3 Operador NOT bit a bit

7.2.4 Unary plus

7.2.5 Resta unaria

7.2.6 Operadores de incremento y decremento prefijos

7.2.7 Operador unario -join

7.2.8 Operador unario -split

7.2.9 Operador de conversión

Operador de coma binario 7.3

7.4 Operador de rango

Operador de formato 7.5

7.6 Operadores multiplicativos

7.6.1 Multiplicación

7.6.2 Replicación de cadenas

7.6.3 Replicación de matriz

7.6.4 División

7.6.5 Resto

7.7 Operadores de suma

7.7.1 Adición

7.7.2 Concatenación de cadenas

7.7.3 Concatenación de matrices

7.7.4 Concatenación de tabla hash

7.7.5 Resta

7.8 Operadores de comparación

7.8.1 Operadores relacionales y igualdad

7.8.2 Operadores de contención

7.8.3 Operadores de prueba y conversión de tipos

7.8.4 Operadores de coincidencia de patrones y manipulación de texto

7.8.4.1 Operadores de -like y -notlike

7.8.4.2 Operadores de -match y -notmatch

7.8.4.3 Operador -replace

7.8.4.4 Operador de -join binario

7.8.4.5 Operador de -split binario

7.8.4.6 Subcoincidencias

7.8.5 Operadores de desplazamiento

7.9 Operadores bit a bit

7.10 Operadores lógicos

7.11 Operadores de asignación

7.11.1 Asignación simple

7.11.2 Asignación compuesta

7.12 Operadores de redireccionamiento

Recursos adicionales