Compartilhar via

2. Estrutura lexical

2.1 Gramáticas

Essa especificação mostra a sintaxe da linguagem do PowerShell usando duas gramáticas. A gramática lexical (§B.1) mostra como os caracteres Unicode são combinados nos terminadores de linha de formulário, comentários, espaço em branco e tokens. A gramática sintática (§B.2) mostra como os tokens resultantes da gramática lexical são combinados para formar scripts do PowerShell.

Para sua conveniência, os fragmentos dessas gramáticas são replicados em locais apropriados em toda essa especificação.

Qualquer uso dos caracteres "a" a "z" nas gramáticas não diferencia maiúsculas de minúsculas. Isso significa que a diferenciação de maiúsculas e minúsculas em variáveis, aliases, nomes de função, palavras-chave, instruções e operadores é ignorada. No entanto, em toda essa especificação, esses nomes são escritos em letras minúsculas, com exceção de algumas variáveis automáticas e de preferência.

2.2 Análise lexical

2.2.1 Scripts

Sintaxe:

Dica

A notação ~opt~ nas definições de sintaxe indica que a entidade lexical é opcional na sintaxe.

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

Descrição:

O fluxo de origem de entrada para um tradutor do PowerShell é a entrada em um script, que contém uma sequência de caracteres Unicode. O processamento lexical desse fluxo envolve a redução desses caracteres em uma sequência de tokens, que passa a se tornar a entrada de análise sintática.

Um script é um grupo de comandos do PowerShell armazenados em um script-file. O próprio script não tem nome, em si, e usa o nome do seu arquivo de origem. O final desse arquivo indica o fim do script.

Um script pode, opcionalmente, conter uma assinatura digital. Um ambiente de host não é necessário para processar qualquer texto que siga uma assinatura ou qualquer coisa que se pareça com uma assinatura. A criação e o uso de assinaturas digitais não são abordados nessa especificação.

2.2.2 Terminadores de linha

Sintaxe:

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

Descrição:

A presença de new-line-character s no fluxo de origem de entrada divide-o em linhas que podem ser usadas para coisas como relatórios de erros e a detecção do final de um comentário de linha única.

Um terminador de linha pode ser tratado como um espaço em branco (§2.2.4).

2.2.3 Comentários

Sintaxe:

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 #

Descrição:

O código-fonte pode ser anotado pelo uso de comentários.

Um single-line-comment começa com o caractere # e termina com um new-line-character.

Um delimited-comment começa com o par de caracteres <# e termina com o par de caracteres #>. Isso pode ocorrer como parte de uma linha de origem, como uma linha de origem inteira ou pode abranger qualquer número de linhas de origem.

Um comentário é tratado como espaço em branco.

As produções acima implicam que

  • Os comentários não podem ser aninhados.
  • As sequências de caracteres <# e #> não têm nenhum significado especial em um comentário de linha única.
  • O caractere # não tem nenhum significado especial em um comentário delimitado.

A gramática lexical implica que os comentários não podem ocorrer dentro de tokens

(confira o §A para saber mais sobre como criar arquivos de script que contêm comentários de valor especial que são usados para gerar documentação de arquivos de script).

Um requires-comment especifica os critérios que devem ser atendidos para que o script que o contém tenha permissão para ser executado. O critério principal é a versão do PowerShell que está sendo usada para executar o script. O requisito de versão mínima é especificado da seguinte maneira:

#requires -Version N[.n]

Em que n é a versão principal (obrigatória) e n é a versão secundária (opcional).

Um requires-comment pode estar presente em qualquer arquivo de script; no entanto, ele não pode estar presente dentro de uma função ou cmdlet. Ele deve ser o primeiro item em uma linha de origem. Um script pode conter vários requires-comment s.

Uma sequência de caracteres só será reconhecida como um comentário se essa sequência começar com # ou <#. Por exemplo, hello#there é considerado um único token, enquanto hello #there é considerado o token hello seguido por um comentário de linha única. Assim como o espaço em branco a seguir, a sequência de início de comentário também pode ser precedida por qualquer caractere de encerramento de expressão ou terminação de instrução (como ), }, ], ', " ou ;).

Um requires-comment não pode estar presente dentro de um snap-in.

Há quatro outras formas de um requires-comment:

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

2.2.4 Espaço em branco

Sintaxe:

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

Descrição:

O espaço em branco consiste em qualquer sequência de um ou mais caracteres de espaço em branco.

Exceto pelo fato de que o espaço em branco pode atuar como separador para tokens, ele é ignorado.

Ao contrário de algumas linguagens populares, o PowerShell não considera os caracteres de terminador de linha (§2.2.2) como espaços em branco. No entanto, um terminador de linha pode ser tratado como um espaço em branco precedendo-o imediatamente por um caractere de acento grave, ` (U+0060). Isso é necessário quando o conteúdo de uma linha é concluído sintaticamente, mas a linha a seguir contém tokens destinados a serem associados à linha anterior. Por exemplo,

$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

Neste exemplo, o acento grave indica que a linha de origem continua. A expressão a seguir é equivalente a $number = 10 + 20 - 50.

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

2.3 Tokens

Sintaxe:

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

Descrição:

Um token é o menor elemento léxico dentro da linguagem do PowerShell.

Os tokens podem ser separados por new-lines, comentários, espaço em branco ou qualquer combinação deles.

2.3.1 Palavras-chave

Sintaxe:

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

Descrição:

Uma palavra-chave é uma sequência de caracteres que tem um significado especial quando usada em um local dependente de contexto. Geralmente, isso é como o primeiro token em uma instrução; no entanto, há outros locais, conforme indicado pela gramática. (Um token que se parece com uma palavra-chave, mas não está sendo usado em um contexto de palavra-chave, é um command-name ou um command-argument.)

As palavras-chave class, define, from, using e var são reservadas para uso futuro.

Observação

Nota do editor: as palavras-chave class e using foram introduzidas no PowerShell 5.0. Confira about_Classes e about_Using.

2.3.2 Variáveis

Sintaxe:

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

Descrição:

As variáveis são discutidas em detalhes em (§5). A variável $? é discutida em §2.3.2.2. Os escopos são discutidos em §3.5.

As variáveis $$ e $^ são reservadas para uso em um ambiente interativo, que está fora do escopo desta especificação.

Há duas maneiras de escrever um nome de variável: um nome de variável entre chaves, que começa com $, seguido por um conjunto delimitado por chaves de um ou mais caracteres quase arbitrários; e um nome de variável comum, que também começa com $, seguido por um conjunto de um ou mais caracteres de um conjunto mais restritivo do que um nome de variável entre chaves permite. Cada nome de variável comum pode ser expresso usando um nome de variável de chave correspondente.

$totalCost
$Maximum_Count_26

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

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

Não há nenhum limite no comprimento de um nome de variável, todos os caracteres em um nome de variável são significativos e não há distinção entre maiúsculas e minúsculas.

Há vários tipos diferentes de variáveis: definido pelo usuário (§2.3.2.1), automático (§2.3.2.2) e preferência (§2.3.2.3). Todos eles podem coexistir no mesmo escopo (§3.5).

Considere a seguinte definição de função e chamadas:

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 é passado por posição ou nome, um de cada vez. No entanto, um conjunto de argumentos pode ser passado como um grupo com expansão em argumentos individuais sendo manipulados pelo ambiente de runtime. Essa expansão automática de argumento é conhecida como nivelamento. Por exemplo,

$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

Isso é obtido usando @ em vez de $ como o primeiro caractere da variável que está sendo passada. Essa notação só pode ser usada em um argumento para um comando.

Os nomes são particionados em vários namespaces, cada um armazenado em uma unidade virtual (§3.1). Por exemplo, as variáveis são armazenadas em Variable:, as variáveis de ambiente são armazenadas em Env:, as funções são armazenadas Function: e os aliases são armazenados em Alias:. Todos esses nomes podem ser acessados como variáveis usando a produção de variable-namespace dentro do variable-scope. Por exemplo,

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

Qualquer uso de um nome de variável com um namespace Variable: explícito é equivalente ao uso do mesmo nome de variável sem essa qualificação. Por exemplo, $v e $Variable:v são intercambiáveis.

Além de ser definido no idioma, as variáveis também podem ser definidas pelo cmdlet New-Variable.

2.3.2.1 Variáveis definidas pelo usuário

Qualquer nome de variável permitido pela gramática, mas não usado por variáveis automáticas ou de preferência, está disponível para variáveis definidas pelo usuário.

As variáveis definidas pelo usuário são criadas e gerenciadas pelo script definido pelo usuário.

2.3.2.2 Variáveis automáticas

As variáveis automáticas armazenam informações de estado sobre o ambiente do PowerShell. Seus valores podem ser lidos no script escrito pelo usuário, mas não gravados.

Observação

A tabela encontrada originalmente neste documento foi removida para reduzir a duplicação. Para obter uma lista completa de variáveis automáticas, consulte about_Automatic_Variables.

2.3.2.3 Variáveis de preferência

As variáveis de preferência armazenam as preferências do usuário para a sessão. Elas são criadas e inicializadas pelo ambiente de runtime do PowerShell. Seus valores podem ser lidos e gravados no script escrito pelo usuário.

Observação

A tabela encontrada originalmente neste documento foi removida para reduzir a duplicação. Para obter uma lista completa das variáveis de preferências, consulte about_Preference_Variables.

2.3.3 Comandos

Sintaxe:

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

Sintaxe:

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

Descrição:

Quando um comando é invocado, as informações podem ser passadas para ele por meio de um ou mais argumentos cujos valores são acessados de dentro do comando por meio de um conjunto de parâmetros correspondentes. O processo de correspondência de parâmetros para argumentos é chamado de associação de parâmetro.

Há três tipos de argumentos:

  • Parâmetro switch (§8.10.5) --tem o formato de command-parameter em que os caracteres first-parameter-char e parameter-chars juntos compõem o nome do switch, que corresponde ao nome de um parâmetro (sem o - inicial) no comando que está sendo invocado. Se os dois-pontos à direita forem omitidos, a presença desse argumento indicará que o parâmetro correspondente será definido como $true. Se os dois pontos à direita estiverem presentes, o argumento imediatamente após deverá designar um valor do tipo bool e o parâmetro correspondente será definido para esse valor. Por exemplo, as seguintes invocações são equivalentes:

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

  • Parâmetro com argumento (§8.10.2) -- tem o formato comando-parâmetro em que primeiro-parâmetro-char e parâmetro-chars juntos compõem o nome do parâmetro, que corresponde ao nome de um parâmetro (sem o - inicial) no comando que está sendo invocado. Não deve haver dois-pontos à direita. O argumento imediatamente após designa um valor associado. Por exemplo, considerando um comando Get-Power, que tem parâmetros $base e $exponent, as seguintes invocações são equivalentes:

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

  • Argumento posicional (§8.10.2) - os argumentos e seus parâmetros correspondentes dentro de comandos têm posições em que o primeiro tem a posição zero. O argumento na posição 0 está associado ao parâmetro na posição 0; o argumento na posição 1 está associado ao parâmetro na posição 1; e assim por diante. Por exemplo, considerando um comando Get-Power, que tem parâmetros $base e $exponent em posições 0 e 1, respectivamente, o seguinte chama esse comando:

    Get-Power 5 3

Confira §8.2 para obter detalhes dos parâmetros especiais -- e --%.

Quando um comando é invocado, um nome de parâmetro pode ser abreviado; qualquer parte à esquerda distinta do nome completo pode ser usada, desde que não seja ambígua em relação aos nomes dos outros parâmetros aceitos pelo mesmo comando.

Para saber mais sobre associação de parâmetros, confira §8.14.

2.3.5 Literais

Sintaxe:

literal:
    integer-literal
    real-literal
    string-literal

2.3.5.1 Literais numéricos

Há dois tipos de literais numéricos: inteiro (§2.3.5.1.1) e real (§2.3.5.1.2). Ambos podem ter sufixos de multiplicador (§2.3.5.1.3).

2.3.5.1.1 Literais de inteiro

Sintaxe:

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

Descrição:

O tipo de um inteiro literal é determinado por seu valor, a presença ou a ausência de long-type-suffix e a presença de um numeric-multiplier (§2.3.5.1.3).

Para um literal inteiro sem long-type-suffix

  • Se o seu valor puder ser representado pelo tipo int (§4.2.3), este será seu tipo;
  • Caso contrário, se o seu valor puder ser representado pelo tipo longo (§4.2.3), este será seu tipo.
  • Caso contrário, se o seu valor puder ser representado pelo tipo decimal (§2.3.5.1.2), este será seu tipo.
  • Caso contrário, ele será representado pelo tipo Double (§2.3.5.1.2).

Para um literal inteiro com long-type-suffix

  • Se o seu valor puder ser representado pelo tipo longo (§4.2.3), este será seu tipo.
  • Caso contrário, esse literal estará mal formado.

Na representação de dois complementos de valores inteiros, há mais um valor negativo do que positivo. Para o tipo int, esse valor extra é ‑2147483648. Para o valor longo, esse valor extra será ‑9223372036854775808. Embora o token 2147483648 normalmente seja tratado como um literal do tipo longo, se ele for precedido imediatamente pelo operador unário, esse operador e o literal serão tratados como um literal do tipo int com o menor valor. Da mesma forma, embora o token 9223372036854775808 normalmente seja tratado como um literal real do tipo decimal, se ele for imediatamente precedido pelo operador unário, esse operador e o literal serão tratados como um literal do tipo longo com o menor valor.

Alguns exemplos de literais inteiros são 123 (int), 123L (longo) e 200000000000 (longo).

Não existe um literal inteiro do tipo byte.

2.3.5.1.2 Literais reais

Sintaxe:

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)

Descrição:

Um literal real pode conter um numeric-multiplier (§2.3.5.1.3).

Há dois tipos de literal real: double e decimal. Eles são indicados pela ausência ou presença, respectivamente, do decimal-type-suffix. (Não existe um literal real flutuante.)

Um literal real duplo tem o tipo double (§4.2.4.1). Um literal real decimal tem o tipo decimal (§ 4.2.4.2). Zeros à direita na parte fracionária de um literal real decimal são significativos.

Se o valor dos decimal-digits da exponent-part em um literal real duplo for menor do que o mínimo compatível, o valor desse literal real duplo será 0. Se o valor dos decimal-digits da exponent-part em um literal real decimal for menor do que o mínimo compatível, esse literal será mal formado. Se o valor dos decimal-digits da exponent-part em um literal real duplo ou decimal for maior do que o máximo compatível, esse literal será mal formado.

Alguns exemplos de literais reais duplos são 1., 1.23, .45e35, 32.e+12 e 123.456E-231.

Alguns exemplos de literais reais decimais são 1d (que tem escala 0), 1.20d (que tem escala 2), 1.23450e1d (ou seja, 12.3450, que tem escala 4), 1.2345e3d (ou seja, 1234.5, que tem escala 1), 1.2345e-1d (ou seja, 0.12345, que tem escala 5) e 1.2345e-3d (ou seja, 0.0012345, que tem escala 7).

Observação

Como um literal real duplo não precisa ter uma parte de fração ou expoente, os parênteses de agrupamento em (123).M são necessários para garantir que a propriedade ou o método M esteja sendo selecionado para o objeto inteiro cujo valor é 123. Sem esses parênteses, o literal real seria mal formado.

Observação

Embora o PowerShell não forneça literais para infinitos e NaNs, equivalentes duplos de literais reais podem ser obtidos das propriedades somente leitura estáticas PositiveInfinity, NegativeInfinity e NaN dos tipos float e double (§4.2.4.1).

A gramática permite que o que começa como um literal real duplo tenha um sufixo l ou L. Esse token é, na verdade, um literal inteiro cujo valor é representado pelo tipo longo.

Observação

Esse recurso foi mantido para fins de compatibilidade com versões anteriores do PowerShell. No entanto, os programadores são desencorajados de usar literais inteiros desse formulário, pois podem facilmente obscurecer o valor real do literal. Por exemplo, 1.2L tem o valor de 1, 1.2345e1L tem o valor de 12 e 1.2345e-5L tem o valor de 0, nenhum dos quais é imediatamente óbvio.

2.3.5.1.3 Sufixos de multiplicador

Sintaxe:

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

Descrição:

Para conveniência, inteiros e literais reais podem conter um numeric-multiplier, que indica um de um conjunto de potências de 10 usadas com frequência. O numeric-multiplier pode ser escrito em qualquer combinação de letras maiúsculas ou minúsculas.

Multiplicador Significado Exemplo
kb kilobyte (1024) 1kb ≡ 1024
mb megabyte (1024 x 1024) 1,30Dmb ≡ 1363148,80
gb gigabyte (1024 x 1024 x 1024) 0x10Gb ≡ 17179869184
tb terabyte (1024 x 1024 x 1024 x 1024) 1,4e23tb ≡ 1,5393162788864E+35
pb petabyte (1024 x 1024 x 1024 x 1024 x 1024) 0x12Lpb ≡ 20266198323167232

2.3.5.2 Literais de cadeia de caracteres

Sintaxe:

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 @

Descrição:

Há quatro tipos de literais de cadeia de caracteres:

  • verbatim-string-literal (linha única entre aspas), que é uma sequência de zero ou mais caracteres delimitados por um par de single-quote-character s. Exemplos: '' e 'red'.

  • expandable-string-literal (linha única entre aspas), que é uma sequência de nenhum ou mais caracteres delimitados por um par de double-quote-character s. Exemplos: "" e "red".

  • verbatim-here-string-literal (com aspas simples de várias linhas), que é uma sequência de nenhum ou mais caracteres delimitados pelos pares de caracteres @single-quote-character e single-quote-character@, respectivamente, todos contidos em duas ou mais linhas de origem. Os exemplos são:

    @'
'@

@'
line 1
'@

@'
line 1
line 2
'@

  • expandable-here-string-literal (com aspas duplas de várias linhas), que é uma sequência de nenhum ou mais caracteres delimitados pelos pares de caracteres @double-quote-character e double-quote-character@, respectivamente, todos contidos em duas ou mais linhas de origem. Os exemplos são:

    @"
"@

@"
line 1
"@

@"
line 1
line 2
"@

Para verbatim-here-string-literal s e expandable-here-string-literal s, exceto pelo espaço em branco (que é ignorado), nenhum caractere pode seguir na mesma linha de origem que o par de caracteres delimitadores de abertura, e nenhum caractere pode preceder na mesma linha de origem que o par de caracteres delimitadores de fechamento.

O corpo de um verbatim-here-string-literal ou um expandable-here-string-literal começa no início da primeira linha de origem após o limite de abertura e termina no final da última linha de origem que precede o delimitador de fechamento. O corpo pode ficar em branco. O terminador de linha na última linha de origem anterior ao delimitador de fechamento não faz parte do corpo desse literal.

Um literal de qualquer um desses tipos tem a cadeia de caracteres de tipo (§4.3.1).

O caractere usado para delimitar um verbatim-string-literal ou expandable-string-literal pode ser contido em um literal de cadeia de caracteres desse tipo escrevendo esse caractere duas vezes, em sucessão. Por exemplo, 'What''s the time?' e "I said, ""Hello"".". No entanto, um single-quote-character não tem nenhum significado especial dentro de um expandable-string-literal e um double-quote-character não tem nenhum significado especial dentro de um verbatim-string-literal.

Um expandable-string-literal e um expandable-here-string-literal podem conter escaped-character s (§2.3.7). Por exemplo, quando o literal de cadeia de caracteres a seguir é gravado no pipeline, o resultado é conforme mostrado abaixo:

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

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

Se um expandable-string-literal ou expandable-here-string-literal contiver o nome de uma variável, a menos que esse nome seja precedido imediatamente por um caractere de escape, ele será substituído pela representação de cadeia de caracteres do valor dessa variável (§6.7). Isso é conhecido como variável de substituição.

Observação

Se o nome da variável for parte de alguma expressão maior, somente o nome da variável será substituído. Por exemplo, se $a for uma matriz que contém os elementos 100 e 200, ">$a.Length<" resulta em >100 200.Length< enquanto ">$($a.Length)<" resulta em >2<. Veja a expansão de subexpressões abaixo.

Por exemplo, o código-fonte

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

resulta no expandable-string-literal

The value of $count is 10.

Considere o seguinte:

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

O resultado é

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

expandable-string-literal s e expandable-here-string-literal s também dão suporte a um tipo de substituição chamado de sub-expression expansion, tratando o texto do formulário $( ... ) como um sub-expression (§7.1.6). Esse texto é substituído pela representação de cadeia de caracteres do valor dessa expressão (§6.8). Qualquer espaço em branco usado para separar tokens na statement-list da sub-expression é ignorado no que diz respeito à construção da cadeia de caracteres de resultado.

Os exemplos

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

resultam nos seguintes expandable-string-literal s:

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

A origem a seguir,

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

resulta nos seguintes expandable-string-literal s:

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

Essas quatro linhas poderiam ter sido escritas de maneira mais sucinta da seguinte maneira:

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

No exemplo a seguir,

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

o expandable-string-literal resultante é o seguinte:

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

Conforme mostrado, uma sub-expression pode conter literais de cadeia de caracteres que têm substituição de variável e expansão de subexpressão. Observe também que os delimitadores expandable-string-literal s internos não precisam de escape; o fato de que eles estão dentro de uma sub-expression significa que eles não podem ser terminadores para o expandable-string-literal externo.

Um expandable-string-literal ou expandable-here-string-literal que contém uma substituição de variável ou expansão de subexpressão é avaliado sempre que esse literal é usado; por exemplo,

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

que resulta nos seguintes expandable-string-literal s:

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

O conteúdo de um verbatim-here-string-literal é tirado textualmente, incluindo qualquer espaço em branco à esquerda ou à direita dentro do corpo. Assim, os single-quote-character s inseridos não precisam ser duplicados e não há substituição ou expansão. Por exemplo,

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

que resulta no literal

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

O conteúdo de um expandable-here-string-literal está sujeito à substituição e à expansão, mas qualquer espaço em branco à esquerda ou à direita dentro do corpo, mas fora de qualquer sub-expression, é feito textualmente e os double-quote-character s não precisam ser duplicados. Por exemplo,

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

que resulta no literal a seguir quando expandido:

That's it!
2 * 3 = 6

Para verbatim-here-string-literal s e expandable-here-string-literal s, cada terminador de linha dentro do corpo está representado no literal resultante de uma maneira definida pela implementação. Por exemplo, no

$lit = @"
abc
xyz
"@

a segunda linha do corpo tem dois espaços à esquerda e a primeira e a segunda linhas do corpo têm terminadores de linha; no entanto, o terminador da segunda linha do corpo não faz parte desse corpo. O literal resultante é equivalente a: "abc<implementation-defined character sequence>xyz".

Observação

Para auxiliar na leitura da origem, literais de cadeia de caracteres longos podem ser divididos em várias linhas de origem sem que terminadores de linha sejam inseridos. Isso é feito escrevendo cada parte como um literal separado e concatenando as partes com o operador + (§7.7.2). Esse operador permite que seus operadores designem qualquer um dos quatro tipos de literal de cadeia de caracteres.

Observação

Embora não exista um literal de caractere em si, o mesmo efeito pode ser obtido acessando o primeiro caractere em uma cadeia de caracteres de 1 caractere, da seguinte maneira: [char]"A" ou "A"[0].

Para verbatim-here-string-literal s e expandable-here-string-literal, cada terminador de linha dentro do corpo é representado exatamente como foi fornecido.

2.3.5.3 Literal nulo

Confira a variável automática $null (§2.3.2.2).

2.3.5.4 Literais boolianos

Confira as variáveis automáticas $false e $true (§2.3.2.2).

2.3.5.5 Literais de matriz

O PowerShell permite que expressões do tipo de matriz (§9) sejam escritas usando o operador de vírgula unária (§7.2.1), array-expression (§7.1.7), o operador de vírgula binário (§7.3) e o operador de intervalo (§7.4).

2.3.5.6 Literais de hash

O PowerShell permite que expressões do tipo Tabela de hash (§10) sejam escritas usando um hash-literal-expression (§7.1.9)

2.3.5.7 Nomes de tipo

Sintaxe:

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 e pontuadores

Sintaxe:

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

Descrição:

&& e || são reservados para uso futuro.

Observação

Observação do editor: os operadores de cadeia de pipeline && e || foram introduzidos no PowerShell 7. Confira about_Pipeline_Chain_Operators.

O nome após dash em um operador é reservado para essa finalidade somente em um contexto de operador.

Um operador que começa com dash não deve ter nenhum espaço em branco entre esse dash e o token que o segue.

2.3.7 Caracteres de escape

Sintaxe:

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

Descrição:

Um caractere de escape é uma maneira de atribuir uma interpretação especial a um caractere, dando a ele um caractere de acento grave de prefixo (U+0060). A tabela a seguir mostra o significado de cada escaped-character:

Caractere de escape Significado
`a Alerta (U+0007)
`b Backspace (U+0008)
`f Feed de formulário (U+000C)
`n Nova linha (U+000A)
`r Retorno de carro (U+000D)
`t Tabulação horizontal (U+0009)
`v Tabulação vertical (U+0009)
`' Aspas simples (U+0027)
`" Aspas duplas (U+0022)
`` Acento grave (U+0060)
`0 NUL (U+0000)
`x Se x for um caractere diferente dos caracteres mostrados acima, o caractere de acento grave será ignorado e x será utilizado literalmente.

A implicação da entrada final na tabela acima é que espaços que, de outra forma, separariam tokens podem fazer parte de um token. Por exemplo, um nome de arquivo que contém um espaço pode ser gravado como Test` Data.txt (bem como 'Test Data.txt' ou "Test Data.txt").