about_Parsing

Descrição curta

Descreve como o PowerShell analisa comandos.

Descrição longa

Quando você insere um comando no prompt de comando, o PowerShell divide o texto do comando em uma série de segmentos chamados tokens e, em seguida, determina como interpretar cada token.

Por exemplo, se você digitar:

Write-Host book

O PowerShell divide o comando em dois tokens, Write-Host e booke interpreta cada token independentemente usando um dos dois principais modos de análise: modo de expressão e modo de argumento.

Observação

À medida que o PowerShell analisa a entrada de comando, ele tenta resolver os nomes de comando para cmdlets ou executáveis nativos. Se um nome de comando não tiver uma correspondência exata, o PowerShell precederá Get- o comando como um verbo padrão. Por exemplo, o PowerShell analisa Process como Get-Process. Não é recomendável usar esse recurso pelos seguintes motivos:

  • É ineficiente. Isso faz com que o PowerShell pesquise várias vezes.
  • Programas externos com o mesmo nome são resolvidos primeiro, portanto, você não pode executar o cmdlet pretendido.
  • Get-Help e Get-Command não reconhecem nomes sem verbo.

Modo de expressão

O modo de expressão destina-se à combinação de expressões, necessárias para manipulação de valor em uma linguagem de script. Expressões são representações de valores na sintaxe do PowerShell e podem ser simples ou compostas, por exemplo:

Expressões literais são representações diretas de seus valores:

'hello'
32

As expressões variáveis carregam o valor da variável que fazem referência:

$x
$script:path

Os operadores combinam outras expressões para avaliação:

-12
-not $Quiet
3 + 7
$input.Length -gt 1
  • Literais de cadeia de caracteres devem estar contidos entre aspas.
  • Números são tratados como valores numéricos em vez de como uma série de caracteres (a menos que escape).
  • operadores , incluindo operadores unários como - e -not e operadores binários como + e -gt, são interpretados como operadores e aplicam suas respectivas operações em seus argumentos (operandos).
  • As expressões de atributo e conversão são analisadas como expressões e aplicadas a expressões subordinadas, por exemplo [int] '7', .
  • As referências de variáveis são avaliadas de acordo com seus valores, mas o splatting (ou seja, colar conjuntos de parâmetros pré-preenchidos) é proibido e causa um erro do analisador.
  • Qualquer outra coisa será tratada como um comando a ser invocado.

Modo de argumento

Ao analisar, o PowerShell procura pela primeira vez interpretar a entrada como uma expressão. Mas quando uma invocação de comando é encontrada, a análise continua no modo de argumento. Se você tiver argumentos que contenham espaços, como caminhos, deverá colocar esses valores de argumento entre aspas.

O modo de argumento foi projetado para analisar argumentos e parâmetros para comandos em um ambiente de shell. Toda a entrada é tratada como uma cadeia de caracteres expansível, a menos que use uma das seguintes sintaxes:

  • O cifrão ($) seguido por um nome de variável inicia uma referência de variável, caso contrário, ela é interpretada como parte da cadeia de caracteres expansível. A referência de variável pode incluir acesso de membro ou indexação.

    • Caracteres adicionais após referências de variáveis simples, como $HOME, são considerados parte do mesmo argumento. Coloque o nome da variável em chaves ({}) para separá-lo dos caracteres subsequentes. Por exemplo, ${HOME}.
    • Quando a referência de variável inclui acesso de membro, o primeiro de quaisquer caracteres adicionais é considerado o início de um novo argumento. Por exemplo, $HOME.Length-more resulta em dois argumentos: o valor de $HOME.Length e a literal de cadeia de caracteres -more.

  • Aspas (' e ") iniciam cadeias de caracteres

  • Chaves ({}) iniciam um novo bloco de script

  • Vírgulas (,) introduzem listas passadas como arrays, exceto quando o comando a ser chamado é um aplicativo nativo, caso em que são interpretadas como parte da string expansível. Não há suporte para vírgulas iniciais, consecutivas ou à direita.

  • Parênteses (()) iniciam uma nova expressão

  • O operador de subexpressão ($()) inicia uma expressão inserida

  • Sinal de arroba inicial (@) inicia sintaxes de expressão, como splatting (@args), matrizes (@(1,2,3)) e literais de tabela de hash (@{a=1;b=2}).

  • (), $()e @() no início de um token criam um novo contexto de análise que pode conter expressões ou comandos aninhados.

    • Quando seguido por caracteres adicionais, o primeiro caractere adicional é considerado o início de um novo argumento separado.
    • Quando precedido por um literal $() sem aspas funciona como uma cadeia de caracteres expansível, () inicia um novo argumento que é uma expressão e @() é considerado literal @ com () o início de um novo argumento que é uma expressão.

  • Todo o resto é tratado como uma cadeia de caracteres expansível, exceto metacaracteres que ainda precisam de escape.

    • Os metacaracters do modo argumento (caracteres com significado sintactico especial) são: <space> ' " ` , ; ( ) { } | & < > @ #. Destes, < > @ # são especiais apenas no início de um token.

  • O token de interrupção de análise (--%) altera a interpretação de todos os argumentos restantes. Para obter mais informações, consulte a seção de token de interrupção de análise abaixo.

Exemplos

A tabela a seguir fornece vários exemplos de tokens processados no modo de expressão e no modo de argumento e a avaliação desses tokens. Para esses exemplos, o valor da variável $a é 4.

Exemplo Modo Resultado
2 Expressão 2 (inteiro)
`2 Expressão "2" (comando)
Write-Output 2 Expressão 2 (inteiro)
2+2 Expressão 4 (inteiro)
Write-Output 2+2 Argumento "2+2" (cadeia de caracteres)
Write-Output(2+2) Expressão 4 (inteiro)
$a Expressão 4 (inteiro)
Write-Output $a Expressão 4 (inteiro)
$a+2 Expressão 6 (inteiro)
Write-Output $a+2 Argumento "4+2" (cadeia de caracteres)
$- Argumento "$-" (comando)
Write-Output $- Argumento "$-" (cadeia de caracteres)
a$a Expressão "a$a" (comando)
Write-Output a$a Argumento "a4" (cadeia de caracteres)
a'$a' Expressão "a$a" (comando)
Write-Output a'$a' Argumento "a$a" (cadeia de caracteres)
a"$a" Expressão "a$a" (comando)
Write-Output a"$a" Argumento "a4" (cadeia de caracteres)
a$(2) Expressão "a$(2)" (comando)
Write-Output a$(2) Argumento "a2" (cadeia de caracteres)

Cada token pode ser interpretado como algum tipo de objeto, como Booleano ou String. O PowerShell tenta determinar o tipo de objeto da expressão. O tipo de objeto depende do tipo de parâmetro que um comando espera e se o PowerShell sabe como converter o argumento no tipo correto. A tabela a seguir mostra vários exemplos dos tipos atribuídos aos valores retornados pelas expressões.

Exemplo Modo Resultado
Write-Output !1 argumento "!1" (cadeia de caracteres)
Write-Output (!1) expressão Falso (Booleano)
Write-Output (2) expressão 2 (inteiro)
Set-Variable AB A,B argumento 'A','B' (matriz)
CMD /CECHO A,B argumento 'A,B' (cadeia de caracteres)
CMD /CECHO $AB expressão 'A B' (matriz)
CMD /CECHO :$AB argumento ':A B' (cadeia de caracteres)

Como passar argumentos para comandos nativos

Ao executar comandos nativos do PowerShell, os argumentos são analisados pela primeira vez pelo PowerShell. Os argumentos analisados são então unidos em uma única cadeia de caracteres com cada parâmetro separado por um espaço.

Por exemplo, o comando a seguir chama o programa icacls.exe.

icacls X:\VMS /grant Dom\HVAdmin:(CI)(OI)F

Para executar esse comando no PowerShell 2.0, você deve usar caracteres de escape para impedir que o PowerShell interprete mal os parênteses.

icacls X:\VMS /grant Dom\HVAdmin:`(CI`)`(OI`)F

O token de parada de análise

A partir do PowerShell 3.0, você pode usar o token stop-parsing (--%) para impedir que o PowerShell interprete a entrada como comandos ou expressões do PowerShell.

Observação

O token de parada de análise destina-se apenas ao uso em plataformas Windows.

Ao chamar um comando nativo, coloque o token de parada de análise antes dos argumentos do programa. Essa técnica é muito mais fácil do que usar caracteres de escape para evitar interpretações incorretas.

Quando o PowerShell encontra um token de parada de análise, trata os caracteres restantes na linha como texto literal. A única interpretação executada é substituir valores para variáveis de ambiente que usam notação padrão do Windows, como %USERPROFILE%.

icacls X:\VMS --% /grant Dom\HVAdmin:(CI)(OI)F

O PowerShell envia a seguinte cadeia de caracteres de comando para o programa icacls.exe:

X:\VMS /grant Dom\HVAdmin:(CI)(OI)F

O "token de análise de parada" só será eficaz até o próximo caractere de nova linha ou de pipeline. Você não pode usar um caractere de continuação (`) para estender seu efeito ou usar um delimitador de comando (;) para encerrar seu efeito.

Além das referências de variáveis de %variable% ambiente, você não pode incorporar nenhum outro elemento dinâmico no comando. Não há suporte para o escape de um % caractere como %%, da maneira que você pode fazer dentro de arquivos em lote. %<name>% tokens são invariavelmente expandidos. Se <name> não se referir a uma variável de ambiente definida, o token será passado por as-is.

Você não pode usar o redirecionamento de fluxo (como >file.txt) porque eles são passados literalmente como argumentos para o comando target.

Passar argumentos que contêm caracteres de aspas

Alguns comandos nativos esperam argumentos que contêm caracteres de aspas. Normalmente, a análise de linha de comando do PowerShell remove o caractere de aspas fornecido. Os argumentos analisados são então unidos em uma única cadeia de caracteres com cada parâmetro separado por um espaço. Essa cadeia de caracteres é atribuída à propriedade Arguments de um ProcessStartInfo objeto. As aspas dentro da cadeia de caracteres devem ser escapadas usando aspas extras ou caracteres de barra invertida (\).

Observação

O caractere de barra invertida (\) não é reconhecido como um caractere de escape pelo PowerShell. É o caractere de escape usado pela API subjacente para ProcessStartInfo.Arguments.

Para obter mais informações sobre os requisitos de escape, consulte a documentação de ProcessStartInfo.Arguments.

Os exemplos a seguir usando a TestExe.exe ferramenta. Essa ferramenta é usada pelos testes do Pester no repositório de origem do PowerShell. O objetivo desses exemplos é passar o caminho "C:\Program Files (x86)\Microsoft\" do diretório para um comando nativo para que ele receba o caminho como uma cadeia de caracteres entre aspas.

O parâmetro echoargs de TestExe exibe os valores recebidos como argumentos para o executável. Você pode usar essa ferramenta para verificar se você escapou corretamente dos caracteres em seus argumentos.

TestExe -echoargs """""${env:ProgramFiles(x86)}\Microsoft\\"""""
TestExe -echoargs """""C:\Program Files (x86)\Microsoft\\"""""
TestExe -echoargs "\""C:\Program Files (x86)\Microsoft\\"""
TestExe -echoargs --% "\"C:\Program Files (x86)\Microsoft\\"
TestExe -echoargs --% """C:\Program Files (x86)\Microsoft\\""
TestExe -echoargs --% """%ProgramFiles(x86)%\Microsoft\\""

A saída é a mesma para todos os exemplos:

Arg 0 is <"C:\Program Files (x86)\Microsoft\">

Você pode compilar o TestExe a partir do código-fonte. Consulte TestExe.

Passando argumentos para comandos do PowerShell

A partir do PowerShell 3.0, você pode usar o token end-of-parameters (--) para impedir que o PowerShell interprete a entrada como parâmetros do PowerShell. Essa é uma convenção especificada na especificação de Shell e Utilitários POSIX.

O token de fim dos parâmetros (--) indica que todos os argumentos que o seguem devem ser passados em sua forma real, como se as aspas duplas fossem colocadas ao seu redor. Por exemplo, usando -- você pode gerar a cadeia de caracteres -InputObject sem usar aspas ou interpretá-la como um parâmetro:

Write-Output -- -InputObject

-InputObject

Ao contrário do token de stop-parsing (--%), todos os valores após o token -- podem ser interpretados como expressões pelo PowerShell.

Write-Output -- -InputObject $env:PROCESSOR_ARCHITECTURE

-InputObject
AMD64

Esse comportamento só se aplica aos comandos do PowerShell. Se você usar o token -- ao chamar um comando externo, a cadeia de caracteres -- será passada como um argumento para esse comando.

TestExe -echoargs -a -b -- -c

A saída mostra que -- é passado como um argumento para TestExe.

Arg 0 is <-a>
Arg 1 is <-b>
Arg 2 is <-->
Arg 3 is <-c>

Consulte também

  • Last updated on