Freigeben über

Über_Parsing

Kurzbeschreibung

Beschreibt, wie PowerShell Befehle analysiert.

Lange Beschreibung

Wenn Sie an der Eingabeaufforderung einen Befehl eingeben, bricht PowerShell den Befehlstext in eine Reihe von Segmenten auf, die Token genannt werden, und bestimmt dann, wie jedes Token interpretiert werden soll.

Wenn Sie beispielsweise Folgendes eingeben:

Write-Host book

PowerShell unterteilt den Befehl in zwei Token, Write-Host und book, und interpretiert jedes Token unabhängig von einem von zwei hauptanalysemodi: Ausdrucksmodus und Argumentmodus.

Hinweis

Da PowerShell Befehlseingaben analysiert, versucht sie, die Befehlsnamen in Cmdlets oder systemeigene ausführbare Dateien aufzulösen. Wenn ein Befehlsname nicht genau übereinstimmt, wird Get- PowerShell dem Befehl als Standardverb vorangestellt. PowerShell analysiert z. B. Process als Get-Process. Es wird nicht empfohlen, dieses Feature aus den folgenden Gründen zu verwenden:

  • Es ist ineffizient. Dies führt dazu, dass PowerShell mehrmals sucht.
  • Externe Programme mit demselben Namen werden zuerst aufgelöst, sodass Sie das beabsichtigte Cmdlet möglicherweise nicht ausführen.
  • Get-Help und Get-Command erkennen keine verblosen Namen.

Ausdrucksmodus

Der Ausdrucksmodus dient zum Kombinieren von Ausdrücken, die für die Wertmanipulation in einer Skriptsprache erforderlich sind. Ausdrücke sind Darstellungen von Werten in der PowerShell-Syntax und können einfach oder zusammengesetzt sein, z. B.:

Literale Ausdrücke sind direkte Darstellungen ihrer Werte:

'hello'
32

Variable Ausdrücke tragen den Wert der Variablen, auf die sie verweisen:

$x
$script:path

Operatoren kombinieren andere Ausdrücke für die Auswertung:

-12
-not $Quiet
3 + 7
$input.Length -gt 1
  • Zeichenfolgen-Literale müssen in Anführungszeichen gesetzt werden.
  • Zahlen werden als numerische Werte und nicht als eine Reihe von Zeichen behandelt (sofern sie nicht escaped sind).
  • Operatoren, einschließlich unärer Operatoren wie - und -not und binäre Operatoren wie + und -gt, werden als Operatoren interpretiert und ihre jeweiligen Vorgänge auf ihre Argumente (Operanden) angewendet.
  • Attribut- und Konvertierungsausdrücke werden als Ausdrücke geparst und auf untergeordnete Ausdrücke angewendet, z.B. [int] '7'.
  • Variablenreferenzen werden auf ihre Werte ausgewertet, aber das Splatting (d.h. das Einfügen von vorausgefüllten Parametersätzen) ist verboten und verursacht einen Parser-Fehler.
  • Alles andere wird als Befehl behandelt, der aufgerufen werden muss.

Diskussionsmodus

Beim Analysieren sucht PowerShell zunächst, eingaben als Ausdruck zu interpretieren. Wenn jedoch ein Befehlsaufruf auftritt, wird die Analyse im Argumentmodus fortgesetzt. Wenn Sie Argumente haben, die Leerzeichen enthalten, z. B. Pfade, müssen Sie diese Argumentwerte in Anführungszeichen setzen.

Der Argumentmodus wurde für die Analyse von Argumenten und Parametern für Befehle in einer Shellumgebung entwickelt. Alle Eingaben werden als erweiterbare Zeichenfolge behandelt, es sei denn, sie verwendet eine der folgenden Syntaxen:

  • Mit dem Dollarzeichen ($), gefolgt von einem Variablennamen, beginnt eine Variablenreferenz, andernfalls wird sie als Teil der erweiterbaren Zeichenkette interpretiert. Die Variablenreferenz kann einen Mitgliedszugriff oder eine Indizierung beinhalten.

    • Zusätzliche Zeichen nach einfachen Variablenverweisen, wie z. B. $HOME, werden als Teil desselben Arguments betrachtet. Schließen Sie den Variablennamen in geschweifte Klammern ({}) ein, um ihn von nachfolgenden Zeichen zu trennen. Beispiel: ${HOME}.
    • Wenn die Variablenreferenz den Memberzugriff einschließt, wird das erste von zusätzlichen Zeichen als Beginn eines neuen Arguments betrachtet. Zum Beispiel ergibt $HOME.Length-more zwei Argumente: den Wert von $HOME.Length und die Zeichenfolge -more.

  • Anführungszeichen (' und ") beginnen Zeichenfolgen

  • Klammern ({}) beginnen eine neue Skriptblockierung

  • Kommas (,) leiten Listen ein, die als Arrays übergeben werden, es sei denn, der aufzurufende Befehl ist eine native Anwendung, in diesem Fall werden sie als Teil des erweiterbaren Strings interpretiert. Anfangs-, aufeinanderfolgende oder nachfolgende Kommas werden nicht unterstützt.

  • Klammern (()) beginnen einen neuen Ausdruck

  • Der Subexpression-Operator ($()) beginnt einen eingebetteten Ausdruck.

  • Das anfängliche at-Zeichen (@) beginnt Ausdrucksschreibweisen wie z. B. Splatting (@args), Arrays (@(1,2,3)) und Hash-Tabellen-Literale (@{a=1;b=2}).

  • (), $()und @() am Anfang eines Tokens erstellen einen neuen Analysekontext, der Ausdrücke oder geschachtelte Befehle enthalten kann.

    • Gefolgt von zusätzlichen Zeichen wird das erste zusätzliche Zeichen als Beginn eines neuen, separaten Arguments betrachtet.
    • Wenn ihm ein Literal $() ohne Anführungszeichen vorangestellt ist, funktioniert es wie eine erweiterbare Zeichenfolge, beginnt ein neues Argument, () das ein Ausdruck ist, und @() wird als Literal @ angesehen, wenn ein neues Argument gestartet wird, bei () dem es sich um einen Ausdruck handelt.

  • Alles andere wird wie eine erweiterbare Zeichenfolge behandelt, mit Ausnahme von Metazeichen, die immer noch mit Escaping versehen werden müssen.

    • Die Argumentmodus-Metacharacter (Zeichen mit spezieller syntaktischer Bedeutung) sind: <space> ' " ` , ; ( ) { } | & < > @ #. Von diesen sind < > @ # nur am Anfang eines Tokens besonders.

  • Das Stoppanalysetoken (--%) ändert die Interpretation aller verbleibenden Argumente. Weitere Informationen finden Sie unter stop-parsing Token unten.

Beispiele

Die folgende Tabelle enthält mehrere Beispiele für Token, die im Ausdrucksmodus und im Argumentmodus verarbeitet werden, und die Auswertung dieser Token. Für diese Beispiele ist der Wert der Variablen $a4.

Beispiel Modus Ergebnis
2 Ausdruck 2 (ganze Zahl)
`2 Ausdruck "2" (Befehl)
Write-Output 2 Ausdruck 2 (ganze Zahl)
2+2 Ausdruck 4 (ganze Zahl)
Write-Output 2+2 Streitpunkt "2+2" (Zeichenfolge)
Write-Output(2+2) Ausdruck 4 (ganze Zahl)
$a Ausdruck 4 (ganze Zahl)
Write-Output $a Ausdruck 4 (ganze Zahl)
$a+2 Ausdruck 6 (ganze Zahl)
Write-Output $a+2 Streitpunkt "4+2" (Zeichenfolge)
$- Streitpunkt "$-" (Befehl)
Write-Output $- Streitpunkt "$-" (Zeichenfolge)
a$a Ausdruck "a$a" (Befehl)
Write-Output a$a Streitpunkt "a4" (Zeichenfolge)
a'$a' Ausdruck "a$a" (Befehl)
Write-Output a'$a' Streitpunkt "a$a" (Zeichenfolge)
a"$a" Ausdruck "a$a" (Befehl)
Write-Output a"$a" Streitpunkt "a4" (Zeichenfolge)
a$(2) Ausdruck "a$(2)" (Befehl)
Write-Output a$(2) Streitpunkt "a2" (Zeichenfolge)

Jedes Token kann als eine Art objekttyp interpretiert werden, z. B. boolesche oder String-. PowerShell versucht, den Objekttyp aus dem Ausdruck zu ermitteln. Der Objekttyp hängt vom Typ des Parameters ab, den ein Befehl erwartet, und ob PowerShell weiß, wie das Argument in den richtigen Typ konvertiert werden kann. Die folgende Tabelle enthält mehrere Beispiele für die Typen, die den von den Ausdrücken zurückgegebenen Werten zugewiesen werden.

Beispiel Modus Ergebnis
Write-Output !1 Streit "!1" (Zeichenfolge)
Write-Output (!1) Ausdruck FALSE (boolesch)
Write-Output (2) Ausdruck 2 (ganze Zahl)
Set-Variable AB A,B Streit A','B' (Array)
CMD /CECHO A,B Streit A,B' (Zeichenfolge)
CMD /CECHO $AB Ausdruck A B' (Array)
CMD /CECHO :$AB Streit :A B' (Zeichenfolge)

Übergeben von Argumenten an native Befehle

Wenn Systemeigene Befehle aus PowerShell ausgeführt werden, werden die Argumente zuerst von PowerShell analysiert. Die analysierten Argumente werden dann mit einer einzelnen Zeichenfolge verknüpft, wobei jeder Parameter durch ein Leerzeichen getrennt ist.

Beispielsweise ruft der folgende Befehl das icacls.exe Programm auf.

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

Um diesen Befehl in PowerShell 2.0 auszuführen, müssen Sie Escapezeichen verwenden, um zu verhindern, dass PowerShell die Klammern falsch interpretiert.

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

Das stop-parsing Token

Ab PowerShell 3.0 können Sie das Stoppanalysetoken (--%) verwenden, um zu verhindern, dass PowerShell Eingaben als PowerShell-Befehle oder -Ausdrücke interpretiert.

Hinweis

Das Stop-Parsing-Token ist nur für die Verwendung auf Windows-Plattformen vorgesehen.

Platzieren Sie beim Aufrufen eines nativen Befehls das Stopp-Parsing-Token vor den Programmargumenten. Diese Technik ist viel einfacher als die Verwendung von Escapezeichen, um Fehlinterpretation zu verhindern.

Wenn PowerShell auf ein stop-parsing Token stößt, behandelt es die verbleibenden Zeichen in der Zeile als ein Literal. Die einzige Interpretation, die sie ausführt, besteht darin, Werte für Umgebungsvariablen zu ersetzen, die die standardmäßige Windows-Schreibweise verwenden, z. B. %USERPROFILE%.

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

PowerShell sendet die folgende Befehlszeichenfolge an das icacls.exe Programm:

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

Das Stop-Parsing-Token ist nur bis zum nächsten Zeilenumbruch oder Pipeline-Zeichen wirksam. Sie können kein Fortsetzungszeichen (`) verwenden, um den Effekt zu verlängern, oder ein Befehlstrennzeichen (;) verwenden, um den Effekt zu beenden.

Abgesehen von %variable% Referenzen auf Umgebungsvariablen können Sie keine anderen dynamischen Elemente in den Befehl einbetten. Das Escapen eines % Zeichens als %%, wie Sie es in Batch-Dateien tun können, wird nicht unterstützt. %<name>% Token werden ausnahmslos erweitert. Wenn <name> nicht auf eine definierte Umgebungsvariable verweist, wird das Token as-isübergeben.

Sie können die Streamumleitung (wie >file.txt) nicht verwenden, da sie wortwörtlich als Argumente an den Zielbefehl übergeben werden.

Übergabe von Argumenten, die Anführungszeichen enthalten

Einige native Befehle erwarten Argumente, die Anführungszeichen enthalten. Normalerweise entfernt die Befehlszeilenanalyse von PowerShell das von Ihnen bereitgestellte Anführungszeichen. Die analysierten Argumente werden dann mit einer einzelnen Zeichenfolge verknüpft, wobei jeder Parameter durch ein Leerzeichen getrennt ist. Diese Zeichenfolge wird dann der Arguments-Eigenschaft eines ProcessStartInfo Objekts zugewiesen. Anführungszeichen innerhalb der Zeichenfolge müssen mit zusätzlichen Anführungszeichen oder umgekehrten Schrägstrichen (\) escapet werden.

Hinweis

Der umgekehrte Schrägstrich (\) wird von PowerShell nicht als Escapezeichen erkannt. Es ist das Escapezeichen, das von der zugrunde liegenden API für ProcessStartInfo.Argumentsverwendet wird.

Weitere Informationen zu den Escapeanforderungen finden Sie in der Dokumentation zu ProcessStartInfo.Arguments.

Im Folgenden finden Sie Beispiele für die Verwendung des TestExe.exe Tools. Dieses Tool wird von den Pester-Tests im PowerShell-Quellrepository verwendet. Ziel dieser Beispiele ist es, den Verzeichnispfad "C:\Program Files (x86)\Microsoft\" an einen systemeigenen Befehl zu übergeben, damit er den Pfad als anführungszeichenierte Zeichenfolge empfangen hat.

Der Echoargs-Parameter zeigt TestExe die werte an, die als Argumente für die ausführbare Datei empfangen wurden. Sie können dieses Tool verwenden, um zu überprüfen, ob die Zeichen in Ihren Argumenten ordnungsgemäß escapet sind.

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\\""

Die Ausgabe ist für alle Beispiele identisch:

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

Sie können TestExe aus dem Quellcode erstellen. Weitere Informationen finden Sie unter TestExe.

Übergabe von Argumenten an PowerShell-Befehle

Ab PowerShell 3.0 können Sie das End-of-Parameters--Token (--) verwenden, um zu verhindern, dass PowerShell Eingaben als PowerShell-Parameter interpretiert. Dies ist eine Konvention, die in der POSIX Shell and Utilities-Spezifikation angegeben ist.

Das End-of-Parameters-Token (--) gibt an, dass alle darauf folgenden Argumente in ihrer tatsächlichen Form übergeben werden sollen, als ob doppelte Anführungszeichen um sie herum platziert wurden. Wenn Sie z. B. -- verwenden, können Sie die Zeichenfolge -InputObject ausgeben, ohne Anführungszeichen zu verwenden oder als Parameter interpretiert zu haben:

Write-Output -- -InputObject

-InputObject

Im Gegensatz zum Stop-Parsing(--%)-Token können alle Werte, die dem -- Token folgen, von PowerShell als Ausdrücke interpretiert werden.

Write-Output -- -InputObject $env:PROCESSOR_ARCHITECTURE

-InputObject
AMD64

Dieses Verhalten gilt nur für PowerShell-Befehle. Wenn Sie das ---Token beim Aufrufen eines externen Befehls verwenden, wird die -- Zeichenfolge als Argument an diesen Befehl übergeben.

TestExe -echoargs -a -b -- -c

Die Ausgabe zeigt, dass -- als Argument an TestExeübergeben wird.

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

Siehe auch

  • Last updated on