about_Parsing

Kurze Beschreibung

Beschreibt, wie PowerShell Befehle analysiert.

Lange Beschreibung

Wenn Sie an der Eingabeaufforderung einen Befehl eingeben, unterbricht PowerShell den Befehlstext in eine Reihe von Segmenten, die als Token bezeichnet werden, und bestimmt dann, wie die einzelnen Token interpretiert werden.

Wenn Sie beispielsweise Folgendes eingeben:

Write-Host book

PowerShell unterbricht den Befehl in zwei Token Write-Host und bookund interpretiert jedes Token unabhängig mit einem von zwei Hauptanalysemodi: Ausdrucksmodus und Argumentmodus.

Hinweis

Wenn PowerShell Befehlseingaben analysiert, versucht es, die Befehlsnamen in Cmdlets oder native ausführbare Dateien aufzulösen. Wenn ein Befehlsname keine genaue Übereinstimmung aufweist, wird der Befehl von PowerShell Get- als Standardverb vorangestellt. PowerShell analysiert Process beispielsweise als Get-Process. Es wird aus den folgenden Gründen nicht empfohlen, dieses Feature zu verwenden:

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

Ausdrucksmodus

Der Ausdrucksmodus ist für die Kombination von Ausdrücken vorgesehen, die für die Wertbearbeitung 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

Variablenausdrü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

• Zeichenfolgenliterale müssen in Anführungszeichen enthalten sein.
• Zahlen werden als numerische Werte und nicht als Eine Reihe von Zeichen behandelt (sofern keine Escapezeichen enthalten sind).
• Operatoren, einschließlich unärer Operatoren wie - und -not und binäre Operatoren wie + und -gt, werden als Operatoren interpretiert und wenden ihre jeweiligen Vorgänge auf ihre Argumente (Operanden) an.
• Attribut- und Konvertierungsausdrücke werden als Ausdrücke analysiert und auf untergeordnete Ausdrücke angewendet, z. B. [int] '7'.
• Variablenverweise werden auf ihre Werte ausgewertet, aber das Splatting (d. h. das Einfügen vorgefüllter Parametersätze) ist verboten und verursacht einen Parserfehler.
• Alles andere wird als Befehl behandelt, der aufgerufen werden soll.

Argumentmodus

Beim Analysieren versucht 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 einschließen.

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

• Das Dollarzeichen ($) gefolgt von einem Variablennamen beginnt einen Variablenverweis, andernfalls wird es als Teil der erweiterbaren Zeichenfolge interpretiert. Der Variablenverweis kann den Memberzugriff oder die Indizierung umfassen.

  • Zusätzliche Zeichen nach einfachen Variablenverweise, z $HOME. B. , werden als Teil desselben Arguments betrachtet. Schließen Sie den Variablennamen in Klammern ({}) ein, um ihn von nachfolgenden Zeichen zu trennen. Beispiel: ${HOME}.
  • Wenn der Variablenverweis den Memberzugriff enthält, wird das erste zusätzliche Zeichen als Beginn eines neuen Arguments betrachtet. $HOME.Length-more Beispielsweise ergibt sich zwei Argumente: der Wert von und das $HOME.Length Zeichenfolgenliteral -more.

• Anführungszeichen (' und ") beginnen Zeichenfolgen

• Klammern ({}) beginnen mit neuen Skriptblöcken

• Kommas (,) führen Listen ein, die als Arrays übergeben werden, außer wenn der zu aufrufende Befehl eine native Anwendung ist, in diesem Fall werden sie als Teil der erweiterbaren Zeichenfolge interpretiert. Anfängliche, aufeinanderfolgende oder nachfolgende Kommas werden nicht unterstützt.

• Klammern (()) beginnen einen neuen Ausdruck

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

• Initial at sign (@) beginnt Ausdruckssyntaxen wie Splatting (@args), Arrays (@(1,2,3)) und Hashtabellenliterale (@{a=1;b=2}).

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

  • Wenn zusätzliche Zeichen folgen, wird das erste zusätzliche Zeichen als Beginn eines neuen, separaten Arguments betrachtet.
  • Wenn ein Literal $() ohne Anführungszeichen vorangestellt wird, funktioniert wie eine erweiterbare Zeichenfolge, () startet ein neues Argument, das ein Ausdruck ist, und @() wird als Literal @ verwendet, wobei () ein neues Argument gestartet wird, das ein Ausdruck ist.

• Alles andere wird als erweiterbare Zeichenfolge behandelt, mit Ausnahme von Metazeichen, die noch entweichen müssen.

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

• Das Token für die Stoppanalyse (--%) ändert die Interpretation aller verbleibenden Argumente. Weitere Informationen finden Sie weiter unten im Abschnitt zum Beenden der Analyse von Token .

Beispiele

Die folgende Tabelle enthält mehrere Beispiele für Token, die im Ausdrucks- und Argumentmodus verarbeitet werden, und die Auswertung dieser Token. In diesen Beispielen ist 4der Wert der Variablen $a .

Beispiel	Mode	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	Argument	"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	Argument	"4+2" (Zeichenfolge)
$-	Argument	"$-" (Befehl)
Write-Output $-	Argument	"$-" (Zeichenfolge)
a$a	Ausdruck	"a$a" (Befehl)
Write-Output a$a	Argument	"a4" (Zeichenfolge)
a'$a'	Ausdruck	"a$a" (Befehl)
Write-Output a'$a'	Argument	"a$a" (Zeichenfolge)
a"$a"	Ausdruck	"a$a" (Befehl)
Write-Output a"$a"	Argument	"a4" (Zeichenfolge)
a$(2)	Ausdruck	"a$(2)" (Befehl)
Write-Output a$(2)	Argument	"a2" (Zeichenfolge)

Jedes Token kann als objekttypisch interpretiert werden, z. B. Boolean oder String. PowerShell versucht, den Objekttyp aus dem Ausdruck zu bestimmen. Der Objekttyp hängt vom Typ des Parameters ab, den ein Befehl erwartet, und davon, 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 sind.

Beispiel	Mode	Ergebnis
Write-Output !1	Argument	"!1" (Zeichenfolge)
Write-Output (!1)	expression	False (Boolesch)
Write-Output (2)	expression	2 (ganze Zahl)
Set-Variable AB A,B	Argument	'A','B' (Array)
CMD /CECHO A,B	Argument	"A,B" (Zeichenfolge)
CMD /CECHO $AB	expression	"A B" (Array)
CMD /CECHO :$AB	Argument	':A B' (Zeichenfolge)

Übergeben von Argumenten an native Befehle

Beim Ausführen nativer Befehle aus PowerShell werden die Argumente zuerst von PowerShell analysiert. Die analysierten Argumente werden dann in eine einzelne Zeichenfolge eingebunden, wobei jeder Parameter durch ein Leerzeichen getrennt ist.

Mit dem folgenden Befehl wird das icacls.exe Programm beispielsweise aufgerufen.

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 Token zum Beenden der Analyse

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

Hinweis

Das Token zum Beenden der Analyse ist nur für die Verwendung auf Windows-Plattformen vorgesehen.

Platzieren Sie beim Aufrufen eines nativen Befehls das Token zum Beenden der Analyse vor den Programmargumenten. Diese Technik ist viel einfacher als die Verwendung von Escapezeichen, um Fehlinterpretationen zu verhindern.

Wenn ein Token für die Stoppanalyse auftritt, behandelt PowerShell die verbleibenden Zeichen in der Zeile als Literal. Die einzige Interpretation besteht darin, Werte durch Umgebungsvariablen zu ersetzen, die die Windows-Standardnotation 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 Token für die Stoppanalyse ist nur bis zum nächsten Zeilen- oder Pipelinezeichen wirksam. Sie können kein Fortsetzungszeichen (`) verwenden, um seine Wirkung zu erweitern, oder ein Befehlstrennzeichen (;) verwenden, um seine Wirkung zu beenden.

Abgesehen von %variable% Umgebungsvariablenbezügen können Sie keine anderen dynamischen Elemente in den Befehl einbetten. Das Auskapseln eines % Zeichens als %%wird nicht unterstützt, wie Sie dies in Batchdateien tun können. %<name>% Token werden immer erweitert. Wenn <name> nicht auf eine definierte Umgebungsvariable verweist, wird das Token unverändert übergeben.

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

Übergeben von Argumenten, die Anführungszeichen enthalten

Einige native Befehle erwarten Argumente, die Anführungszeichen enthalten. Normalerweise entfernt die PowerShell-Befehlszeilenanalyse das von Ihnen angegebene Anführungszeichen. Die analysierten Argumente werden dann in eine einzelne Zeichenfolge eingebunden, wobei jeder Parameter durch ein Leerzeichen getrennt ist. Diese Zeichenfolge wird dann der Arguments-Eigenschaft eines ProcessStartInfo -Objekts zugewiesen. Anführungszeichen in der Zeichenfolge müssen mit zusätzlichen Anführungszeichen oder umgekehrten Schrägstrichen (\) versehen 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.

In den folgenden Beispielen wird das TestExe.exe Tool verwendet. Dieses Tool wird von den Pester-Tests im PowerShell-Quellrepository verwendet. Das Ziel dieser Beispiele besteht darin, den Verzeichnispfad "C:\Program Files (x86)\Microsoft\" an einen nativen Befehl zu übergeben, sodass er den Pfad als Anführungszeichen empfängt.

Der echoargs-Parameter von TestExe zeigt die empfangenen Werte als Argumente für die ausführbare Datei an. Sie können dieses Tool verwenden, um zu überprüfen, ob Sie die Zeichen in Ihren Argumenten ordnungsgemäß mit Escapezeichen versehen haben.

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.

Übergeben von Argumenten an PowerShell-Befehle

Ab PowerShell 3.0 können Sie das Token für das Ende der Parameter (--) verwenden, um die Interpretation von Eingaben durch PowerShell als PowerShell-Parameter zu beenden. Dies ist eine Konvention, die in der POSIX Shell and Utilities-Spezifikation angegeben ist.

Das Token für das Ende der Parameter (--) gibt an, dass alle folgenden Argumente in ihrer tatsächlichen Form übergeben werden sollen, als würden doppelte Anführungszeichen um sie herum platziert. Beispielsweise können Sie die Zeichenfolge -InputObject ausgeben--, ohne Anführungszeichen zu verwenden oder sie als Parameter interpretieren zu lassen:

Write-Output -- -InputObject

-InputObject

Im Gegensatz zum Token zum Beenden der Analyse (--%) 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>

Weitere Informationen

• about_Command_Syntax