Partilhar via

2. Estrutura lexical

Nota editorial

Importante

A Especificação da Linguagem PowerShell Windows 3.0 foi publicada em dezembro de 2012 e baseia-se no Windows PowerShell 3.0. Esta especificação não reflete o estado atual do PowerShell. Não há nenhum plano para atualizar esta documentação para refletir o estado atual. Esta documentação é apresentada aqui para referência histórica.

O documento de especificação está disponível como documento Microsoft Word no Centro de Transferências da Microsoft em: https://www.microsoft.com/download/details.aspx?id=36389 Esse documento Word foi convertido para apresentação aqui no Microsoft Learn. Durante a conversão, algumas alterações editoriais foram feitas para acomodar a formatação da plataforma do Documentos. Alguns erros de digitação e pequenos erros foram corrigidos.

2.1 Gramáticas

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

Por conveniência, fragmentos dessas gramáticas são replicados em locais apropriados ao longo desta especificação.

Qualquer uso dos caracteres 'a' a 'z' nas gramáticas é insensível a maiúsculas e minúsculas. Isso significa que letras maiúsculas e minúsculas em variáveis, apelidos, nomes de funções, palavras-chave, instruções e operadores são ignoradas. No entanto, ao longo desta especificação, tais nomes são escritos em minúsculas, exceto para algumas variáveis automáticas e de preferência.

2.2 Análise lexical

2.2.1 Guiões

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 entrada para um intérprete do PowerShell é o 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 se tornam a entrada da análise sintática.

Um script é um grupo de comandos do PowerShell armazenados em um arquivo de script . O script em si não tem nome, per se, e leva seu nome de seu arquivo de origem. O final desse arquivo indica o fim do script.

Um script pode, opcionalmente, conter uma assinatura digital. Um ambiente 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 cobertos por esta 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 caracteres de nova linha no fluxo de origem de entrada divide-o em linhas que podem ser usadas para tarefas tais como o relatório de erros e a deteção do final de um comentário de linha única.

Um terminador de linha pode ser tratado como 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 através de comentários .

Um comentário de linha única começa com o carácter # e termina com um carácter de nova linha .

Um comentário delimitado começa com o par de caracteres <# e termina com o par de caracteres #>. 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 são organizados em níveis.
  • As sequências de caracteres <# e #> não têm significado especial em um comentário de linha única.
  • O caractere # não tem significado especial em um comentário delimitado.

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

(Consulte §A para obter informações sobre como criar arquivos de script que contêm comentários com valor especial que são usados para gerar documentação a partir de arquivos de script.)

Um requires-comment especifica os critérios que devem ser atendidos para que o seu script contido seja permitido executar. 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 forma:

#Requires -Version N[.n]

Onde N é a versão principal (necessária) e n é a versão secundária (opcional).

Um requer comentário pode estar presente em qualquer arquivo de script; no entanto, ele não pode estar presente dentro de uma função ou cmdlet. Deve ser o primeiro item em uma linha de origem. Um script pode conter múltiplos requires-comments.

Uma sequência de caracteres só é 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. Além de seguir o espaço em branco, a sequência de início de comentários também pode ser precedida por qualquer caractere de terminação de expressão ou de declaração (como ), }, ], ', "ou ;).

Um com requerimento de comentário não pode estar presente dentro de um snap-in.

Existem quatro outras formas de um requer comentários:

#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:

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

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

Ao contrário de algumas linguagens populares, o PowerShell não considera caracteres terminadores de linha (§2.2.2) como espaço em branco. No entanto, um terminador de linha pode ser tratado como espaço em branco se for imediatamente precedido por um caractere de backtick, ` (U+0060). Isso é necessário quando o conteúdo de uma linha está completo 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 backtick indica que a linha de origem é continuada. 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 Fichas

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 lexical dentro da linguagem PowerShell.

Os tokens podem ser separados por novas linhas, 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 do contexto. Na maioria das vezes, isto ocorre como o primeiro token em uma afirmação ; no entanto, existem outros locais, como indicado pela gramática. (Um token que se parece com uma palavra-chave, mas não está a ser usado num contexto de palavra-chave, é um nome de comando ou um argumento de comando.)

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

Observação

Nota do Editor: As palavras-chave class e using foram introduzidas no PowerShell 5.0. Ver sobre_Classes e sobre_Uso.

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 detalhe em (§5). A variável $? é discutido no §2.3.2.2. Os escopos são discutidos no §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 colchetes , que começa com $, seguido por um conjunto de um ou mais caracteres quase arbitrários delimitados por chaves; 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 o que um nome de variável entre colchetes permite. Cada nome de variável comum pode ser expresso usando um nome de variável correspondente entre chavetas.

$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á limite para o comprimento de um nome de variável, todos os caracteres num nome de variável são significativos e maiúsculas e minúsculas não são distintas.

Existem vários tipos diferentes de variáveis: definidas pelo utilizador (§2.3.2.1), automáticas (§2.3.2.2) e preferenciais (§2.3.2.3). Todos podem coexistir no mesmo âmbito (§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 por nome, um a um. No entanto, um conjunto de argumentos pode ser passado como um grupo, com a expansão destes em argumentos individuais sendo manipulada pelo ambiente de execução em tempo real. Essa expansão automática de argumento é conhecida como splatting. 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

Isto é conseguido 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 dos quais é 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 em Function:e os aliases são armazenados em Alias:. Todos esses nomes podem ser acessados como variáveis usando a produção de variável-namespace dentro do escopo variável . 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 desse mesmo nome de variável sem essa qualificação. Por exemplo, $v e $Variable:v são intercambiáveis.

Além de serem definidas na linguagem, as variáveis também podem ser definidas pelo cmdlet New-Variable.

2.3.2.1 Variáveis definidas pelo utilizador

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 por 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 em script escrito pelo usuário, mas não escritos.

Observação

A tabela originalmente encontrada 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. Eles são criados e inicializados pelo ambiente de tempo de execução do PowerShell. Seus valores podem ser lidos e escritos em script escrito pelo usuário.

Observação

A tabela originalmente encontrada neste documento foi removida para reduzir a duplicação. Para obter uma lista completa de variáveis de preferência, 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 através de um ou mais argumentos cujos valores são acessados de dentro do comando através de um conjunto de parâmetros de correspondentes. O processo de associação de parâmetros a argumentos é chamado de vinculação de parâmetros.

Existem três tipos de argumentos:

  • [switch] parâmetro (§8.10.5) -- Este tem a forma de comando-parâmetro onde first-parameter-char e parameter-chars juntos formam o nome do switch, que corresponde ao nome de um parâmetro (sem o início -) no comando invocado. Se os dois pontos finais forem omitidos, a presença deste argumento indica que o parâmetro correspondente deve ser configurado para $true. Se os dois pontos à direita estiverem presentes, o argumento imediatamente a seguir deve designar um valor do tipo bool, e o parâmetro correspondente é definido como 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) -- Este tem a forma command-parameter onde first-parameter-char e parameter-chars juntos compõem o nome do parâmetro, que corresponde ao nome de um parâmetro (sem sua principal -) no comando que está sendo invocado. Não deve haver dois pontos finais. O argumento imediatamente a seguir designa um valor associado. Por exemplo, dado 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) - Argumentos e seus parâmetros correspondentes dentro de comandos têm posições com o primeiro tendo posição zero. O argumento na posição 0 está ligado ao parâmetro na posição 0; o argumento na posição 1 está ligado ao parâmetro na posição 1; e assim por diante. Por exemplo, dado um comando Get-Power, que tem parâmetros $Base e $Exponent nas posições 0 e 1, respectivamente, o seguinte invoca esse comando:

    Get-Power 5 3

Ver §8.2 para mais pormenores sobre os parâmetros especiais -- e --%.

Quando um comando é invocado, um nome de parâmetro pode ser abreviado; Pode ser utilizada qualquer parte distintiva do nome completo, desde que não seja ambígua no que diz respeito aos nomes dos outros parâmetros aceites pelo mesmo comando.

Para obter informações sobre a vinculação de parâmetros, consulte §8.14.

2.3.5 Literais

Sintaxe:

literal:
    integer-literal
    real-literal
    string-literal

2.3.5.1 Literais numéricos

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

2.3.5.1.1 Literais inteiros

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 hexadecimal-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 literal inteiro é determinado pelo seu valor, pela presença ou ausência de sufixo de tipo longo, e pela presença de multiplicador numérico (§2.3.5.1.3).

Para um número inteiro sem sufixo de tipo longo

  • Se o seu valor pode ser representado pelo tipo int (§4.2.3), esse é o seu tipo;
  • Caso contrário, se o seu valor puder ser representado pelo tipo long (§4.2.3), esse é o seu tipo.
  • Caso contrário, se o seu valor puder ser representado pelo tipo decimal (§2.3.5.1.2), esse é o seu tipo.
  • Caso contrário, é representado pelo tipo double (§2.3.5.1.2).

Para um literal inteiro com sufixo de tipo longo

  • Se o seu valor pode ser representado pelo tipo long (§4.2.3), esse é o seu tipo;
  • Caso contrário, esse literal está 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 tipo longo, esse valor extra é -9223372036854775808. Embora o token 2147483648 normalmente seja tratado como um literal do tipo long, se for precedido imediatamente pelo operador unário "-", esse operador e o literal são tratados como um literal do tipo int com o menor valor possível. Da mesma forma, mesmo que o token 9223372036854775808 normalmente seja tratado como um literal real do tipo decimal, se for imediatamente precedido pelo operador unário, esse operador e literal são tratados como um literal do tipo longo com o menor valor.

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

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 multiplicador numérico (§2.3.5.1.3).

Existem dois tipos de literal real: duplo e decimal. Estes são indicados pela ausência ou presença, respectivamente, do sufixo do tipo decimal . (Não existe um literal do tipo float real .)

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

Se o valor de parte do expoente de dígitos decimais em um literal real de dupla precisão for menor do que o mínimo permitido, o valor desse literal real de dupla precisão é 0. Se o valor de parte expoentedígitos decimais em um literal real decimal for menor do que o mínimo suportado, esse literal está mal formado. Se o valor de parte expoentedígitos decimais em um literal real duplo ou decimal for maior do que o máximo suportado, esse literal está 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 fração ou parte expoente, o agrupamento entre parênteses em (123). M são necessários para garantir que a propriedade ou o método M está sendo selecionado para o objeto inteiro cujo valor é 123. Sem esses parênteses, o literal real ficaria mal formado.

Observação

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

A gramática permite que aquilo que começa como um literal real duplo tenha um sufixo de tipo l ou L. Tal token é realmente um literal inteiro cujo valor é representado pelo tipo long.

Observação

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

2.3.5.1.3 Sufixos multiplicadores

Sintaxe:

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

Descrição:

Por conveniência, literais inteiros e reais podem conter um multiplicador numérico, que indica um de um conjunto de potências comumente usadas de 10. multiplicador numérico 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 strings

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:

Existem quatro tipos de literais de cadeia de caracteres:

  • (single-line single-quoted) verbatim-string-literal, que é uma sequência de zero ou mais caracteres delimitada por um par de aspas simples . Exemplos são '' e 'vermelho'.

  • literal de cadeia de caracteres expansível (entre aspas duplas numa única linha), que é uma sequência de zero ou mais caracteres delimitada por um par de caracteres aspas duplas. Exemplos são "" e "vermelho".

  • literal-verbatim-aqui-string (citação simples em várias linhas), que é uma cadeia de zero ou mais caracteres delimitada pelos pares @caractere-aspas-simples e caractere-aspas-simples@, respectivamente, todos distribuídos por duas ou mais linhas de origem. São exemplos:

    @'
'@

@'
line 1
'@

@'
line 1
line 2
'@

  • expansível-aqui-string-literal (aspas duplas de várias linhas), que é uma sequência de zero ou mais caracteres delimitada pelos pares de caracteres @ de aspas duplas e de aspas duplas @, respectivamente, todos contidos em duas ou mais linhas de origem. São exemplos:

    @"
"@

@"
line 1
"@

@"
line 1
line 2
"@

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

O corpo de um literal de string aqui-verbatim ou de um literal de string aqui-expansível começa no início da primeira linha de origem após o delimitador de abertura e termina no final da última linha de origem que antecede o delimitador de fechamento. O corpo pode estar vazio. O terminador de linha na última linha de origem que precede o delimitador de fechamento não faz parte do corpo desse literal.

Um literal de qualquer um desses tipos tem o tipo string (§4.3.1).

O caractere usado para delimitar um literal de cadeia de caracteres verbatim ou literal de cadeia de caracteres expansível pode ser incluído em tal literal de cadeia de caracteres escrevendo esse caractere duas vezes seguidas. Por exemplo, 'What''s the time?' e "I said, ""Hello"".". No entanto, um caractere de aspas simples não tem significado especial dentro de um literal de string expansível, e um caractere de aspas duplas não tem significado especial dentro de um literal de string literal .

Um literal de string expansível e um literal de string-aqui expansível podem conter caracteres escapados (§2.3.7). Por exemplo, quando o seguinte string literal é gravado no pipeline, o resultado é mostrado abaixo:

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

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

Se uma string literal expansível ou uma string literal expansível aqui contiver o nome de uma variável, a menos que esse nome seja precedido imediatamente por um carácter de escape, ele será substituído pela representação como string do valor dessa variável (§6.7). Isto é conhecido como substituição variável.

Observação

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

Por exemplo, o código-fonte

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

resulta na string literal expansível 

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

string literal expansívele aqui string literal expansíveltambém suportam um tipo de substituição chamada expansão de subexpressão, tratando o texto da forma $( ... ) como uma subexpressão (§7.1.6). Esse texto é substituído pela representação em cadeia do valor dessa expressão (§6.8). Qualquer espaço em branco usado para separar tokens dentro da lista de instruções da subexpressão é 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 literais de string expansíveis:

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

A seguinte fonte,

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

resulta na seguinte cadeia literal expansível :

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

Estas quatro linhas poderiam ter sido escritas de forma mais sucinta da seguinte forma:

"`$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 literal de cadeia expansível 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

Como mostrado, uma subexpressão pode conter literais de cadeia que incluem substituição de variáveis e expansão de subexpressão. Observe também que os delimitadores do literal de string expansível interno não precisam ser escapados; o fato de estarem dentro de uma subexpressão significa que eles não podem ser terminadores para o literal de string expansível externo.

Um literal de cadeia extensível ou literal de cadeia extensível aqui contendo uma substituição de variável ou expansão de subexpressão é avaliado cada vez que o literal é usado; por exemplo

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

que resultam nas seguintes cadeias de caracteres literais expansíveis :

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

O conteúdo de um verbatim-here-string-literal é tomado literalmente, incluindo qualquer espaço em branco iniciais ou finais dentro do corpo. Como tal, os caracteres de aspas simples embutidosnão precisam ser duplicados e não há substituição ou expansão. Por exemplo

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

o que resulta na expressão literal

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

O conteúdo de um literal de cadeia expansível está sujeito a substituições e expansões, mas qualquer espaço em branco à esquerda ou à direita dentro do corpo, mas fora de qualquer subexpressão é tomado literalmente, e os caracteres de aspas duplas incorporadas não precisam ser duplicados. Por exemplo

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

o que resulta no seguinte resultado literal quando expandido:

That's it!
2 * 3 = 6

Para ambos os verbatim-here-string-literal e expandable-here-string-literal, cada terminador de linha dentro do corpo é representado no literal resultante de uma forma definida pela implementação. Por exemplo, em

$lit = @"
abc
xyz
"@

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

Observação

Para ajudar na legibilidade do código fonte, sequências de caracteres longas podem ser quebradas em várias linhas de origem sem inserir terminadores de linha. Isto é feito escrevendo cada parte como um literal separado e concatenando as partes com o operador + (§7.7.2). Este operador permite que seus operandos designem qualquer um dos quatro tipos de literal de cadeia de caracteres.

Observação

Embora não exista um literal de caractere per se, o mesmo efeito pode ser alcançado acessando o primeiro caractere em uma cadeia de 1 caractere, da seguinte forma: [char]"A" ou "A"[0].

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

2.3.5.3 Literal nulo

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

2.3.5.4 Literais booleanos

Ver 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), de expressão de matriz (§7.1.7), o operador de vírgula binária (§7.3) e o operador de intervalo (§7.4).

2.3.5.6 Literais de hash

O PowerShell permite que expressões do tipo Hashtable (§10) sejam escritas usando uma expressão literal de hash (§7.1.9)

2.3.5.7 Nomes dos tipos

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 || estão reservados para uso futuro.

Observação

Nota do editor: Os operadores da cadeia de pipeline && e || foram introduzidos no PowerShell 7. Ver about_Pipeline_Chain_Operators.

O nome a seguir ao travessão entre e num operador é reservado para esse efeito apenas num contexto de operador.

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

2.3.7 Caracteres escapados

Sintaxe:

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

Descrição:

Um caractere escapado é uma maneira de atribuir uma interpretação especial a um caractere, dando-lhe um prefixo Backtick (U+0060). A tabela a seguir mostra o significado de cada carácter escapado .

Personagem escapado Significado
`a Alerta (U+0007)
`b Backspace (U+0008)
`f Alimentação de formulários (U+000C)
`n Nova linha (U+000A)
`r Retorno de carro (U+000D)
`t Tabulação horizontal (U+0009)
`v Tabulação horizontal (U+0009)
`' Cotação única (U+0027)
`" Citação dupla (U+0022)
`` Backtick (U + 0060)
`0 NUL (U+0000)
`x Se x for um caractere diferente dos mostrados acima, o caractere de backtick será ignorado e x será tomado literalmente.

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

  • Last updated on