Compartir a través de

2. Estructura léxica

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.

2.1 Gramáticas

Esta especificación muestra la sintaxis del lenguaje de PowerShell mediante dos gramáticas. La gramática léxica (§B.1) muestra cómo se combinan los caracteres Unicode para formar terminadores de línea, comentarios, espacios en blanco y tokens. La gramática sintáctica (§B.2) muestra cómo se combinan los tokens resultantes de la gramática léxica para formar scripts de PowerShell.

Para mayor comodidad, los fragmentos de estas gramáticas se replican en lugares adecuados a lo largo de esta especificación.

Cualquier uso de los caracteres "a" hasta la "z" en las gramáticas no distingue entre mayúsculas y minúsculas. Esto significa que se ignora el uso de mayúsculas y minúsculas en las variables, alias, nombres de función, palabras clave, instrucciones y operadores. Sin embargo, a lo largo de esta especificación, estos nombres se escriben en minúsculas, excepto en algunas variables automáticas y de preferencia.

2.2 Análisis léxico

2.2.1 Scripts

Sintaxis:

Sugerencia

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

input:
    input-elements~opt~   signature-block~opt~

input-elements:
    input-element
    input-elements   input-element

input-element:
    whitespace
    comment
    token

signature-block:
    signature-begin   signature   signature-end

signature-begin:
    new-line-character   # SIG # Begin signature block   new-line-character

signature:
    base64 encoded signature blob in multiple single-line-comments

signature-end:
    new-line-character   # SIG # End signature block   new-line-character

Descripción:

El flujo de origen de entrada a un traductor de PowerShell es el valor input de un script, que contiene una secuencia de caracteres Unicode. El procesamiento léxico de esta secuencia implica la reducción de esos caracteres en una secuencia de tokens, que van a convertirse en la entrada del análisis sintáctico.

Un script es un grupo de comandos de PowerShell almacenados en un archivo de script de . El propio script no tiene nombre, por se, y toma su nombre de su archivo de origen. El final de ese archivo indica el final del script.

Un script puede contener opcionalmente una firma digital. Un entorno de host no es necesario para procesar ningún texto que siga una firma o cualquier cosa que parezca una firma. La creación y el uso de firmas digitales no están cubiertas por esta especificación.

2.2.2 Terminadores de línea

Sintaxis:

new-line-character:
    Carriage return character (U+000D)
    Line feed character (U+000A)
    Carriage return character (U+000D) followed by line feed character (U+000A)

new-lines:
    new-line-character
    new-lines new-line-character

Descripción:

La presencia de instancias de new-line-character en la secuencia de origen de entrada la divide en líneas que se pueden usar para, por ejemplo, la generación de informes de errores y la detección del final de un comentario de una sola línea.

Un terminador de línea se puede tratar como espacio en blanco (§2.2.4).

2.2.3 Comentarios

Sintaxis:

comment:
    single-line-comment
    requires-comment
    delimited-comment

single-line-comment:
    # input-characters~opt~

input-characters:
    input-character
    input-characters input-character

input-character:
    Any Unicode character except a new-line-character

requires-comment:
    #requires whitespace command-arguments

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

dashdash:
    dash dash

delimited-comment:
    < # delimited-comment-text~opt~ hashes >

delimited-comment-text:
    delimited-comment-section
    delimited-comment-text delimited-comment-section

delimited-comment-section:
    >
    hashes~opt~  not-greater-than-or-hash

hashes:
    #
    hashes #

not-greater-than-or-hash:
    Any Unicode character except > or #

Descripción:

Se pueden usar comentarios para realizar anotaciones en el código fuente.

Una instancia de single-line-comment comienza con el carácter # y termina con new-line-character.

Un comentario delimitado comienza con el par de caracteres <# y termina con el par de caracteres #>. Puede producirse como parte de una línea de origen, como una línea de origen completa, o puede abarcar cualquier número de líneas de origen.

Un comentario se trata como espacio en blanco.

Las producciones anteriores implican que

  • Los comentarios no se anidan.
  • Las secuencias de caracteres <# y #> no tienen ningún significado especial en un comentario de una sola línea.
  • El carácter # no tiene ningún significado especial en un comentario delimitado.

La gramática léxica implica que los comentarios no se pueden producir dentro de tokens.

(Consulte §A para obtener información sobre cómo crear archivos de script que contengan comentarios con valores especiales que se usan para generar documentación a partir de archivos de script).

Un valor requires-comment especifica los criterios que deben cumplirse para que pueda ejecutarse el script que lo contiene. El criterio principal es la versión de PowerShell que se usa para ejecutar el script. El requisito de versión mínima se especifica de la siguiente manera:

#requires -Version N[.n]

Donde N es la versión principal (obligatoria) y n es la versión secundaria (opcional).

Un elemento requires-comment puede estar presente en cualquier archivo de script; sin embargo, no puede estar dentro de una función o cmdlet. Debe ser el primer elemento de una línea de origen. Un script puede contener varias instancias de requires-comment.

Una secuencia de caracteres solo se reconoce como comentario si esa secuencia comienza con # o <#. Por ejemplo, hello#, se considera un único token, mientras que hello #there se considera el token hello seguido de un comentario de una sola línea. Además del espacio en blanco siguiente, la secuencia de inicio del comentario también puede ir precedida de cualquier carácter de terminación de una expresión o de una instrucción (como ), }, ], ', " o ;).

Un elemento requires-comment no puede estar presente dentro de un complemento.

Una instancia de requires-comment puede aparecer de cuatro formas más:

#requires --Assembly AssemblyId
#requires --Module ModuleName
#requires --PsSnapIn PsSnapIn [ -Version *N* [.n] ]
#requires --ShellId ShellId

2.2.4 Espacio en blanco

Sintaxis:

whitespace:
    Any character with Unicode class Zs, Zl, or Zp
    Horizontal tab character (U+0009)
    Vertical tab character (U+000B)
    Form feed character (U+000C)
    ` (The backtick character U+0060) followed by new-line-character

Descripción:

El espacio en blanco consta de una secuencia cualquiera de uno o más caracteres de espacio en blanco.

Salvo por el hecho de que el espacio en blanco pueda actuar como separador de los tokens, este se ignora.

A diferencia de algunos lenguajes populares, PowerShell no considera que los caracteres de terminador de línea (§2.2.2) sean espacios en blanco. Sin embargo, un terminador de línea puede tratarse como espacio en blanco si va precedido inmediatamente por un carácter de tilde aguda, ` (U+0060). Esto es necesario cuando el contenido de una línea se completa sintácticamente, pero la línea siguiente contiene tokens destinados a asociarse a la línea anterior. Por ejemplo

$number = 10 # assigns 10 to $number; nothing is written to the pipeline
+ 20 # writes 20 to the pipeline
- 50 # writes -50 to the pipeline
$number # writes $number's value, 10, to the pipeline

En este ejemplo, la tilde aguda indica que la línea de origen continúa. La expresión siguiente es equivalente a $number = 10 + 20 - 50.

$number = 10 `
+ 20 `
- 50
$number # writes $number's value to the pipeline
-20

2.3 Tokens

Sintaxis:

token:
    keyword
    variable
    command
    command-parameter
    command-argument-token
    integer-literal
    real-literal
    string-literal
    type-literal
    operator-or-punctuator

Descripción:

Un token de es el elemento léxico más pequeño dentro del lenguaje de PowerShell.

Los tokens se pueden separar por instancias de new-lines, comentarios, espacios en blanco o cualquier combinación de estos.

2.3.1 Palabras clave

Sintaxis:

keyword: one of
    begin          break          catch       class
    continue       data           define      do
    dynamicparam   else           elseif      end
    exit           filter         finally     for
    foreach        from           function    if
    in             inlinescript   parallel    param
    process        return         switch      throw
    trap           try            until       using
    var            while          workflow

Descripción:

Una palabra clave es una secuencia de caracteres que tiene un significado especial cuando se usa en un lugar dependiente del contexto. Este suele ser con frecuencia el primer token de una instrucción; sin embargo, hay otras ubicaciones, como se indica en la gramática. (Un token similar a una palabra clave, pero que no se usa en un contexto de palabra clave, es un nombre de comando o un argumento de comando).

Las palabras clave class, define, from, usingy var están reservadas para su uso futuro.

Nota

Nota del editor: Las palabras clave class y using se introdujeron en PowerShell 5.0. Vea about_Classes y about_Using.

2.3.2 Variables

Sintaxis:

variable:
    $$
    $?
    $^
    $   variable-scope~opt~  variable-characters
    @   variable-scope~opt~  variable-characters
    braced-variable


braced-variable:
    ${   variable-scope~opt~   braced-variable-characters   }

variable-scope:
    global:
    local:
    private:
    script:
    using:
    workflow:
    variable-namespace

variable-namespace:
    variable-characters   :

variable-characters:
    variable-character
    variable-characters   variable-character

variable-character:
    A Unicode character of classes Lu, Ll, Lt, Lm, Lo, or Nd
    _   (The underscore character U+005F)
    ?

braced-variable-characters:
    braced-variable-character
    braced-variable-characters   braced-variable-character

braced-variable-character:
    Any Unicode character except
        }   (The closing curly brace character U+007D)
        `   (The backtick character U+0060)
    escaped-character

escaped-character:
    `   (The backtick character U+0060) followed by any Unicode character

Descripción:

Las variables se describen detalladamente en (§5). Las variable $? se describe en §2.3.2.2. Los ámbitos se tratan en §3.5.

Las variables $$ y $^ están reservadas para su uso en un entorno interactivo, que está fuera del ámbito de esta especificación.

Hay dos formas de escribir un nombre de variable: como nombre de variable entre llaves, que comienza por $, seguido de un conjunto delimitado por llaves de uno o varios caracteres prácticamente arbitrarios; o bien como nombre de variable ordinario, que también comienza por $, seguido de un conjunto de uno o varios caracteres de un conjunto más restrictivo de lo que permite un nombre de variable entre llaves. Cada nombre de variable ordinario se puede expresar con un nombre de variable entre llaves correspondiente.

$totalCost
$Maximum_Count_26

$végösszeg # Hungarian
$итог # Russian
$総計 # Japanese (Kanji)

${Maximum_Count_26}
${Name with`twhite space and `{punctuation`}}
${E:\\File.txt}

No hay límite de longitud para un nombre de variable, todos los caracteres de este son significativos y no distingue mayúsculas de minúsculas.

Hay varios tipos diferentes de variables: definidas por el usuario (§2.3.2.1), automática (§2.3.2.2) y preferencia (§2.3.2.3). Todos pueden coexistir en el mismo ámbito (§3.5).

Tenga en cuenta la siguiente definición de función y llamadas:

function Get-Power ([long]$base, [int]$exponent) { ... }

Get-Power 5 3 # $base is 5, $exponent is 3
Get-Power -exponent 3 -base 5 # " " "

Cada argumento se pasa por posición o nombre, de uno en uno. Sin embargo, un conjunto de argumentos puede pasarse como grupo con expansión a argumentos individuales que el entorno de ejecución se encarga de controlar. Esta expansión automática de argumentos se conoce como expansión. Por ejemplo

$values = 5,3 # put arguments into an array
Get-Power @values

$hash = @{ exponent = 3; base = 5 } # put arguments into a Hashtable
Get-Power @hash

function Get-Power2 { Get-Power @args } # arguments are in an array

Get-Power2 --exponent 3 --base 5 # named arguments splatted named in
@args
Get-Power2 5 3 # position arguments splatted positionally in @args

Esto se logra mediante @ en lugar de $ como primer carácter de la variable que se pasa. Esta notación solo se puede usar en un argumento para un comando.

Los nombres se dividen en varios espacios de nombres, cada uno de los cuales se almacena en una unidad virtual (§3.1). Por ejemplo, las variables se almacenan en Variable:, las variables de entorno se almacenan en Env:, las funciones se almacenan en Function:y los alias se almacenan en Alias:. Puede accederse a todos estos nombres como variables mediante la producción variable-namespace en variable-scope. Por ejemplo

function F { "Hello from F" }
$Function:F # invokes function F

Set-Alias A F
$Alias:A # invokes function F via A

$Count = 10
$Variable:Count # accesses variable Count
$Env:Path # accesses environment variable Path

Cualquier uso de un nombre de variable con un espacio de nombres de Variable: explícito es equivalente al uso de ese mismo nombre de variable sin esa calificación. Por ejemplo, $v y $Variable:v son intercambiables.

Además de definirse en el lenguaje, las variables también se pueden definir mediante el cmdlet New-Variable.

2.3.2.1 Variables definidas por el usuario

Cualquier nombre de variable permitido por la gramática, pero no utilizado por las variables automáticas o de preferencia está disponible para las variables definidas por el usuario.

Las variables definidas por el usuario se crean y administran mediante script definido por el usuario.

2.3.2.2 Variables automáticas

Las variables automáticas almacenan información de estado sobre el entorno de PowerShell. Sus valores se pueden leer en el script escrito por el usuario, pero no se pueden escribir.

Nota

La tabla que se encontró originalmente en este documento se quitó para reducir la duplicación. Para obtener una lista completa de variables automáticas, consulte about_Automatic_Variables.

2.3.2.3 Variables de preferencia

Las variables de preferencia almacenan las preferencias de usuario para la sesión. El entorno de tiempo de ejecución de PowerShell los crea e inicializa. Sus valores se pueden leer y escribir en el script escrito por el usuario.

Nota

La tabla que se encontró originalmente en este documento se quitó para reducir la duplicación. Para obtener una lista completa de las variables de preferencia, consulte about_Preference_Variables.

2.3.3 Comandos

Sintaxis:

generic-token:
    generic-token-parts

generic-token-parts:
    generic-token-part
    generic-token-parts generic-token-part

generic-token-part:
    expandable-string-literal
    verbatim-here-string-literal
    variable
    generic-token-char

generic-token-char:
    Any Unicode character except
        {   }   (   )   ;   ,   |   &   $
        ` (The backtick character U+0060)
        double-quote-character
        single-quote-character
        whitespace
        new-line-character
        escaped-character

generic-token-with-subexpr-start:
    generic-token-parts $(

2.3.4 Parámetros

Sintaxis:

command-parameter:
    dash first-parameter-char parameter-chars colon~opt~

first-parameter-char:
    A Unicode character of classes Lu, Ll, Lt, Lm, or Lo
    _ (The underscore character U+005F)
    ?

parameter-chars:
    parameter-char
    parameter-chars parameter-char

parameter-char:
    Any Unicode character except
        { } ( ) ; , \| & . [
        colon
        whitespace
        new-line-character

colon:
    : (The colon character U+003A)

verbatim-command-argument-chars:
    verbatim-command-argument-part
    verbatim-command-argument-chars verbatim-command-argument-part

verbatim-command-argument-part:
    verbatim-command-string
    & non-ampersand-character
    Any Unicode character except
        |
        new-line-character

non-ampersand-character:
    Any Unicode character except &

verbatim-command-string:
    double-quote-character non-double-quote-chars
    double-quote-character

non-double-quote-chars:
    non-double-quote-char
    non-double-quote-chars non-double-quote-char

non-double-quote-char:
    Any Unicode character except
        double-quote-character

Descripción:

Cuando se invoca un comando, se puede pasar información a él a través de uno o varios argumentos cuyos valores se acceden desde dentro del comando a través de un conjunto de parámetros de correspondientes. El proceso de coincidencia de parámetros con argumentos se denomina enlace de parámetros .

Hay tres tipos de argumentos:

  • Parámetro switch ($8.10.5): tiene el formato command-parameter, donde first-parameter-char y parameter-chars juntos conforman el nombre del modificador, que corresponde al nombre de un parámetro (sin - inicial) en el comando que se invoca. Si los dos puntos finales se omiten, la presencia de este argumento indica que el parámetro correspondiente se establece en $true. Si los dos puntos finales están presentes, el argumento inmediatamente a continuación debe designar un valor de tipo booleano y el parámetro correspondiente se establece en ese valor. Por ejemplo, las siguientes invocaciones son equivalentes:

    Set-MyProcess -Strict
Set-MyProcess -Strict: $true

  • Parámetro con el argumento (§8.10.2) - Tiene el formato command-parameter donde first-parameter-char y parameter-chars juntos componen el nombre del parámetro, que corresponde al nombre de un parámetro (sin su inicial -) en el comando que se invoca. No debe haber dos puntos finales. El argumento siguiente designa inmediatamente un valor asociado. Por ejemplo, dado un comando Get-Power, que tiene parámetros $base y $exponent, las siguientes invocaciones son equivalentes:

    Get-Power -base 5 -exponent 3
Get-Power -exponent 3 -base 5

  • Argumento posicional (§8.10.2): los argumentos y sus parámetros correspondientes dentro de los comandos tienen posiciones con la primera posición cero. El argumento en la posición 0 está enlazado al parámetro en la posición 0; el argumento de la posición 1 está enlazado al parámetro en la posición 1; y así sucesivamente. Por ejemplo, dado un comando Get-Power, que tiene parámetros $base y $exponent en las posiciones 0 y 1, respectivamente, lo siguiente invoca ese comando:

    Get-Power 5 3

Consulte §8.2 para obtener más información sobre los parámetros especiales -- y --%.

Cuando se invoca un comando, se puede abreviar un nombre de parámetro; se puede usar cualquier parte inicial distinta del nombre completo, siempre que sea inequívoca con respecto a los nombres de los demás parámetros aceptados por el mismo comando.

Para obtener información sobre el enlace de parámetros, consulte §8.14.

2.3.5 Literales

Sintaxis:

literal:
    integer-literal
    real-literal
    string-literal

2.3.5.1 Literales numéricos

Hay dos tipos de literales numéricos: entero (§2.3.5.1.1) y real (§2.3.5.1.2). Ambos pueden tener sufijos multiplicadores (§2.3.5.1.3).

2.3.5.1.1 Literales enteros

Sintaxis:

integer-literal:
    decimal-integer-literal
    hexadecimal-integer-literal

decimal-integer-literal:
    decimal-digits numeric-type-suffix~opt~ numeric-multiplier~opt~

decimal-digits:
    decimal-digit
    decimal-digit decimal-digits

decimal-digit: one of
    0  1  2  3  4  5  6  7  8  9

numeric-type-suffix:
    long-type-suffix
    decimal-type-suffix

hexadecimal-integer-literal:
    0x hexadecimal-digits long-type-suffix~opt~
    numeric-multiplier~opt~

hexadecimal-digits:
    hexadecimal-digit
    hexadecimal-digit decimal-digits

hexadecimal-digit: one of
    0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f

long-type-suffix:
    l

numeric-multiplier: one of
    kb mb gb tb pb

Descripción:

El tipo de un literal entero viene determinado por su valor, la presencia o ausencia de sufijo de tipo largoy la presencia de un multiplicador numérico (§2.3.5.1.3).

Para un literal entero sin long-type-suffix

  • Si su valor se puede representar por tipo int (§4.2.3), que es su tipo;
  • De lo contrario, si su valor se puede representar mediante el tipo long (§4.2.3), que es su tipo.
  • De lo contrario, si su valor se puede representar mediante el tipo decimal (§2.3.5.1.2), que es su tipo.
  • En caso contrario, se representa mediante el tipo double (§2.3.5.1.2).

Para un literal entero con long-type-suffix

  • Si su valor se puede representar mediante el tipo long (§4.2.3), que es su tipo;
  • En caso contrario, ese literal tiene un formato incorrecto.

En la representación de dos complementos de valores enteros, hay un valor más negativo que el positivo. Para el tipo int, ese valor adicional es -2147483648. Para el tipo largo, ese valor adicional es -9223372036854775808. Aunque el token 2147483648 se trataría normalmente como literal de tipo long, si va precedido inmediatamente por el operador - unario, el operador y el literal se tratan como un literal de tipo int que tiene el valor más pequeño. Del mismo modo, aunque el token 9223372036854775808 normalmente se trataría como un literal real de tipo decimal, si está inmediatamente precedido por el operador unario - , ese operador y literal se tratan como un literal de tipo long que tiene el valor más pequeño.

Algunos ejemplos de literales enteros son 123 (int), 123L (long) y 200000000000 (long).

No existe un literal entero de tipo byte.

2.3.5.1.2 Literales reales

Sintaxis:

real-literal:
    decimal-digits . decimal-digits exponent-part~opt~ decimal-type-suffix~opt~ numeric-multiplier~opt~
    . decimal-digits exponent-part~opt~ decimal-type-suffix~opt~ numeric-multiplier~opt~
    decimal-digits exponent-part decimal-type-suffix~opt~ numeric-multiplier~opt~

exponent-part:
    e sign~opt~  decimal-digits

sign: one of
    +
    dash

decimal-type-suffix:
    d
    l

numeric-multiplier: one of
    kb mb gb tb pb

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

Descripción:

Un literal real puede contener un elemento numeric-multiplier (§2.3.5.1.3).

Hay dos tipos de literales reales: doble y decimal. Estos se indican mediante la ausencia o presencia, respectivamente, de sufijo del tipo decimal. (No existe un literal real flotante).

Un literal real doble tiene el tipo double ($4.2.4.1). Un literal real decimal tiene el tipo decimal (§4.2.4.2). Los ceros finales en la parte de fracción de un literal real decimal son significativos.

Si el valor del elemento decimal-digits de exponent-part en un literal real doble es inferior al mínimo admitido, el valor de ese literal real doble es 0. Si el valor del elemento decimal-digits de exponent-part en un literal real decimal es inferior al mínimo admitido, ese literal tiene un formato incorrecto. Si el valor del elemento decimal-digits de exponent-part en un literal real doble o decimal es superior al máximo admitido, ese literal tiene un formato incorrecto.

Algunos ejemplos de literales reales dobles son 1., 1.23, .45e35, 32.e+12 y 123.456E-231.

Algunos ejemplos de literales reales decimales son 1d (que tiene escala 0), 1,20d (que tiene escala 2), 1,23450e1d (es decir, 12,3450, que tiene escala 4), 1,2345e3d (es decir, 1234.5, que tiene escala 1), 1,2345e-1d (es decir, 0,12345, que tiene escala 5) y 1,2345e-3d (es decir, 0,0012345, que tiene escala 7).

Nota

Dado que un literal real doble no necesita tener una fracción o una parte exponente, los paréntesis de agrupación en (123).M son necesarios para asegurar que se selecciona la propiedad o el método M para el objeto entero cuyo valor es 123. Sin esos paréntesis, el literal real estaría mal formado.

Nota

Aunque PowerShell no proporciona literales para los valores infinitos y NaN, pueden obtenerse equivalentes similares a literales reales dobles de las propiedades estáticas de solo lectura PositiveInfinity, NegativeInfinity y NaN de los tipos float y double (§4.2.4.1).

La gramática permite que lo que comienza como un literal real doble tenga un sufijo de tipo l o L. Este token es realmente un literal entero cuyo valor se representa mediante el tipo long.

Nota

Esta característica se ha conservado por motivos de compatibilidad con versiones anteriores de PowerShell. Sin embargo, no se recomienda que los programadores usen literales enteros de este formato, ya que pueden ocultar fácilmente el valor real del literal. Por ejemplo, 1,2L tiene el valor 1, 1,2345e1L tiene el valor 12 y 1,2345e-5L tiene el valor 0, ninguno de los cuales es inmediatamente obvio.

2.3.5.1.3 Sufijos de multiplicador

Sintaxis:

numeric-multiplier: *one of*
    kb mb gb tb pb

Descripción:

Para mayor comodidad, los literales enteros y reales pueden contener un elemento numeric-multiplier, que indica un conjunto de potencias de 10 usadas habitualmente. El multiplicador numérico se puede escribir en cualquier combinación de letras mayúsculas o minúsculas.

Multiplicador Significado Ejemplo
kb kilobyte (1024) 1 kb ≡ 1024
mb megabyte (1024 x 1024) 1,30Dmb ≡ 1.363.148,80
gb gigabyte (1024 x 1024 x 1024) 0x10Gb ≡ 17179869184
tb terabyte (1024 x 1024 x 1024 x 1024) 1.4e23 tb ≡ 1.5393162788864E+35
pb petabyte (1024 x 1024 x 1024 x 1024 x 1024) 0x12Lpb ≡ 20266198323167232

2.3.5.2 Literales de cadena

Sintaxis:

string-literal:
    expandable-string-literal
    expandable-here-string-literal
    verbatim-string-literal
    verbatim-here-string-literal

expandable-string-literal:
    double-quote-character expandable-string-characters~opt~  dollars~opt~ double-quote-character

double-quote-character:
    " (U+0022)
    Left double quotation mark (U+201C)
    Right double quotation mark (U+201D)
    Double low-9 quotation mark (U+201E)

expandable-string-characters:
      expandable-string-part
      expandable-string-characters
      expandable-string-part

expandable-string-part:
    Any Unicode character except
        $
        double-quote-character
        ` (The backtick character U+0060)
    braced-variable
    $ Any Unicode character except
        (
        {
        double-quote-character
        ` (The backtick character U+0060)*
    $ escaped-character
    escaped-character
    double-quote-character double-quote-character

dollars:
    $
    dollars $

expandable-here-string-literal:
    @  double-quote-character  whitespace~opt~  new-line-character
        expandable-here-string-characters~opt~  new-line-character  double-quote-character  @

expandable-here-string-characters:
    expandable-here-string-part
    expandable-here-string-characters  expandable-here-string-part

expandable-here-string-part:
    Any Unicode character except
        $
        new-line-character
    braced-variable
    $ Any Unicode character except
        (
        new-line-character
    $ new-line-character  Any Unicode character except double-quote-char
    $ new-line-character double-quote-char  Any Unicode character except @
    new-line-character  Any Unicode character except double-quote-char
    new-line-character double-quote-char  Any Unicode character except @

expandable-string-with-subexpr-start:
    double-quote-character  expandable-string-chars~opt~  $(

expandable-string-with-subexpr-end:
    double-quote-char

expandable-here-string-with-subexpr-start:
    @  double-quote-character  whitespace~opt~  new-line-character  expandable-here-string-chars~opt~  $(

expandable-here-string-with-subexpr-end:
    new-line-character  double-quote-character  @

verbatim-string-literal:
    single-quote-character verbatim-string-characters~opt~ single-quote-char

single-quote-character:
    ' (U+0027)
    Left single quotation mark (U+2018)
    Right single quotation mark (U+2019)
    Single low-9 quotation mark (U+201A)
    Single high-reversed-9 quotation mark (U+201B)

verbatim-string-characters:
    verbatim-string-part
    verbatim-string-characters verbatim-string-part

verbatim-string-part:
    *Any Unicode character except* single-quote-character
    single-quote-character  single-quote-character

verbatim-here-string-literal:
    @ single-quote-character whitespace~opt~  new-line-character
        verbatim-here-string-characters~opt~  new-line-character
            single-quote-character *@*

verbatim-*here-string-characters:
    verbatim-here-string-part
    verbatim-here-string-characters  verbatim-here-string-part

verbatim-here-string-part:
    Any Unicode character except* new-line-character
    new-line-character  Any Unicode character except single-quote-character
    new-line-character  single-quote-character  Any Unicode character except @

Descripción:

Hay cuatro tipos de literales de cadena:

  • verbatim-string-literal (una sola línea y comillas simples), que es una secuencia de cero o más caracteres delimitada por un par de elementos single-quote-characters. Algunos ejemplos son '' y 'rojo'.

  • expandable-string-literal (una sola línea y comillas dobles), que es una secuencia de cero o más caracteres delimitada por un par de elementos double-quote-characters. Algunos ejemplos son "" y "rojo".

  • verbatim-here-string-literal (multilínea y comillas simples), que es una secuencia de cero o más caracteres delimitada por los pares de caracteres @single-quote-character y single-quote-character@ respectivamente,incluidos en dos o más líneas de origen. Algunos ejemplos son:

    @'
'@

@'
line 1
'@

@'
line 1
line 2
'@

  • expandable-here-string-literal (multilínea y comillas dobles), que es una secuencia de cero o más caracteres delimitada por los pares de caracteres @double-quote-character y double-quote-character@ respectivamente, incluidos en dos o más líneas de origen. Algunos ejemplos son:

    @"
"@

@"
line 1
"@

@"
line 1
line 2
"@

En lo que respecta a los elementos verbatim-here-string-literal y expandable-here-string-literal, excepto el espacio en blanco (que se ignora), no puede seguirlos ningún carácter en la misma línea de origen que el par de caracteres delimitadores de apertura y ningún carácter puede precederlos en la misma línea de origen que el par de caracteres delimitadores de cierre.

El cuerpo de un elemento verbatim-here-string-literal o expandable-here-string-literal comienza al principio de la primera línea de origen después del delimitador de apertura y termina al final de la última línea de origen que precede al delimitador de cierre. El cuerpo puede estar vacío. El terminador de línea de la última línea de origen que precede al delimitador de cierre no forma parte del cuerpo del literal.

Un literal de cualquiera de estas variantes tiene el tipo string (§4.3.1).

El carácter que se usa para delimitar un elemento verbatim-string-literal o expandable-string-literal puede incluirse en este tipo de literal de cadena al escribir ese carácter dos veces, de forma sucesiva. Por ejemplo, 'What''s the time?' y "I said, ""Hello"".". Sin embargo, un elemento single-quote-character no tiene ningún significado especial dentro de expandable-string-literal y un elemento double-quote-character no tiene ningún significado especial dentro de verbatim-string-literal.

Los elementos expandable-string-literal y expandable-here-string-literal pueden contener instancias de escaped-character (§2.3.7). Por ejemplo, cuando se escribe el literal de cadena siguiente en la canalización, el resultado es el siguiente:

"column1`tcolumn2`nsecond line, `"Hello`", ```Q`5`!"

column1<horizontal-tab>column2<new-line>
second line, "Hello", `Q5!

Si un expandable-string-literal o un expandable-here-string-literal contiene el nombre de una variable, a menos que ese nombre esté precedido inmediatamente por un carácter de escape, se reemplaza por la cadena que representa el valor de esa variable (§6.7). Esto se conoce como sustitución de variables.

Nota

Si el nombre de la variable forma parte de alguna expresión mayor, solo se reemplaza el nombre de la variable. Por ejemplo, si $a es una matriz que contiene los elementos 100 y 200, ">$a.Length<" da como resultado >100 200.Length< mientras que ">$($a.Length)<" da como resultado >2<. Vea la expansión de subexpresiones a continuación.

Por ejemplo, el código fuente

$count = 10
"The value of `$count is $count"

da como resultado expandable-string-literal

The value of $count is 10.

Tenga en cuenta lo siguiente:

$a = "red","blue"
"`$a[0] is $a[0], `$a[0] is $($a[0])" # second [0] is taken literally

El resultado es

$a[0] is red blue[0], $a[0] is red

Los elementos expandable-string-literals y expandable-here-string-literals también admiten un tipo de sustitución denominada expansión de subexpresiones, con el que el texto con formato $( ... ) se trata como subexpresión (§7.1.6). Este texto se reemplaza por la representación de cadena del valor de esa expresión (§6.8). Todo espacio en blanco que se use para separar los tokens dentro de la lista de instrucciones de la subexpresión se omite en la construcción de la cadena de resultados.

Los ejemplos,

$count = 10
"$count + 5 is $($count + 5)"
"$count + 5 is `$($count + 5)"
"$count + 5 is `$(`$count + 5)"

dan como resultado los literales de cadena expansibles (expandable-string-literal) siguientes:

10 + 5 is 15
10 + 5 is $(10 + 5)
10 + 5 is $($count + 5)

El origen siguiente,

$i = 5; $j = 10; $k = 15
"`$i, `$j, and `$k have the values $( $i; $j; $k )"

da como resultado la siguiente cadena literal expandible :

$i, $j, and $k have the values 5 10 15

Estas cuatro líneas podrían haberse escrito más concisamente de la siguiente manera:

"`$i, `$j, and `$k have the values $(($i = 5); ($j = 10); ($k = 15))"

En el ejemplo siguiente,

"First 10 squares: $(for ($i = 1; $i -le 10; ++$i) { "$i $($i*$i) " })"

el elemento expandable-string-literal resultante es el siguiente:

First 10 squares: 1 1 2 4 3 9 4 16 5 25 6 36 7 49 8 64 9 81 10 100

Tal y como se muestra, una subexpresión puede contener literales de cadena que tengan tanto sustitución de variables como expansión de subexpresiones. Tenga en cuenta también que no es necesario aplicar caracteres de escape a los delimitadores del elemento expandable-string-literal interno; el hecho de que se encuentren dentro de una subexpresión significa que no pueden ser terminadores para el elemento expandable-string-literal externo.

Cada vez que se usa ese literal, se evalúa un elemento expandable-string-literal o expandable-here-string-literal que contiene una sustitución de variables o una expansión de subexpresiones; por ejemplo,

$a = 10
$s1 = "`$a = $($a; ++$a)"
"`$s1 = >$s1<"
$s2 = "`$a = $($a; ++$a)"
"`$s2 = >$s2<"
$s2 = $s1
"`$s2 = >$s2<"

da como resultado los elementos expandable-string-literal siguientes:

$s1 = >$a = 10<
$s2 = >$a = 11<
$s2 = >$a = 10<

El contenido de un elemento verbatim-here-string-literal se interpreta textualmente, incluidos los espacios en blanco iniciales o finales dentro del cuerpo. De esta forma, no es necesario duplicar los elementos single-quote-character insertados y no hay ninguna sustitución o expansión. Por ejemplo

$lit = @'
That's it!
2 * 3 = $(2*3)
'@

que da como resultado el literal

That's it!
2 * 3 = $(2*3)

El contenido de un elemento expandable-here-string-literal está sujeto a la sustitución y expansión, pero cualquier espacio en blanco inicial o final dentro del cuerpo pero fuera de cualquier subexpresión se interpreta textualmente y no es necesario duplicar los elementos double-quote-character insertados. Por ejemplo

$lit = @"
That's it!
2 * 3 = $(2*3)
"@

que da como resultado el literal siguiente al expandirse:

That's it!
2 * 3 = 6

Tanto para los elementos verbatim-here-string-literal como para expandable-here-string-literal, cada terminador de línea dentro del cuerpo se representa en el literal resultante de forma definida por la implementación. Por ejemplo, en

$lit = @"
abc
xyz
"@

la segunda línea del cuerpo tiene dos espacios iniciales y las líneas primera y segunda del cuerpo tienen terminadores de línea; sin embargo, el terminador de la segunda línea del cuerpo no forma parte de ese cuerpo. El literal resultante es equivalente a: "abc<implementation-defined character sequence>xyz".

Nota

Para mejorar la legibilidad del código fuente, los literales de cadena largos pueden dividirse en varias líneas de origen sin necesidad de insertar terminadores de línea. Para ello, escriba cada parte como un literal independiente y concatene las partes con el operador + (§7.7.2). Este operador permite que sus operandos designen cualquiera de los cuatro tipos de literal de cadena.

Nota

Aunque no existe un literal de carácter en sí, puede lograrse el mismo efecto si se accede al primer carácter de una cadena de un carácter, como se muestra a continuación: [char]"A" o "A"[0].

Para ambos elementos verbatim-here-string-literal y expandable-here-string-literal, cada terminador de línea dentro del cuerpo se representa tal y como se proporcionó exactamente.

2.3.5.3 Literal NULL

Consulte la variable automática $null (§2.3.2.2).

2.3.5.4 Literales booleanos

Consulte las variables automáticas $false y $true (§2.3.2.2).

2.3.5.5 Literales de matriz

PowerShell permite escribir expresiones de tipo de matriz (§9) mediante el operador unario coma (§7.2.1), array-expression (§7.1.7), el operador binario de comas (§7.3) y el operador de intervalo (§7.4).

2.3.5.6 Literales hash

PowerShell permite escribir expresiones de tipo Hashtable (§10) mediante una expresión hash-literal-expression (§7.1.9)

2.3.5.7 Nombres de tipo

Sintaxis:

type-name:
    type-identifier
    type-name . type-identifier

type-identifier:
    type-characters

type-characters:
    type-character
    type-characters type-character

type-character:
    A Unicode character of classes Lu, Ll, Lt, Lm, Lo, or Nd
    _ (The underscore character U+005F)

array-type-name:
    type-name [

generic-type-name:
    type-name [

2.3.6 Operadores y signos de puntuación

Sintaxis:

operator-or-punctuator: one of
    {   }   [   ]   (   )   @(   @{   $(   ;
    &&  ||  &   |   ,   ++  ..   ::   .
    !   *   /   %   +   -   --
    -and   -band   -bnot   -bor
    -bxor   -not   -or     -xor
    assignment-operator
    merging-redirection-operator
    file-redirection-operator
    comparison-operator
    format-operator

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

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

comparison-operator: *one of
    -as           -ccontains      -ceq
    -cge          -cgt            -cle
    -clike        -clt            -cmatch
    -cne          -cnotcontains   -cnotlike
    -cnotmatch    -contains       -creplace
    -csplit       -eq             -ge
    -gt           -icontains      -ieq
    -ige          -igt            -ile
    -ilike        -ilt            -imatch
    -in           -ine            -inotcontains
    -inotlike     -inotmatch      -ireplace
    -is           -isnot          -isplit
    -join         -le             -like
    -lt           -match          -ne
    -notcontains  -notin         -notlike
    -notmatch     -replace       -shl*
    -shr          -split

format-operator:
    -f

Descripción:

&& y || están reservados para uso futuro.

Nota

Nota del editor: Los operadores de la cadena de canalización && y || se introdujeron en PowerShell 7. Consulte about_Pipeline_Chain_Operators.

El nombre que sigue al guion en un operador se reserva solo para ese fin en un contexto de operador.

Un operador que comienza con un guion no debe tener ningún espacio en blanco entre ese guion y el token que lo sigue.

2.3.7 Caracteres de escape

Sintaxis:

escaped-character:
    ` (The backtick character U+0060) followed by any Unicode character

Descripción:

Un carácter de escape es una forma de asignar una interpretación especial a un carácter al proporcionarle un carácter de tilde aguda de prefijo (U+0060). En la tabla siguiente se muestra el significado de cada carácter de escape:

Carácter de escape Significado
`a Alerta (U+0007)
`b Retroceso (U+0008)
`f Avance de página (U+000C)
`n Nueva línea (U+000A)
`r Retorno de carro (U+000D)
`t Tabulación horizontal (U+0009)
`v Tabulación vertical (U+0009)
`' Comillas simples (U+0027)
`" Comillas dobles (U+0022)
`` Tilde aguda (U+0060)
`0 NUL (U+0000)
`x Si x es un carácter distinto de los que se muestran anteriormente, el carácter de tilde aguda se omite y x se interpreta literalmente.

La implicación de la entrada final de la tabla anterior es que los espacios que, de lo contrario, separarían los tokens pueden pasar a formar parte de un token en su lugar. Por ejemplo, un nombre de archivo que contiene un espacio se puede escribir como Test` Data.txt (así como 'Test Data.txt' o "Test Data.txt").