about_Parsing

Korte beschrijving

Hierin wordt beschreven hoe PowerShell opdrachten parseert.

Lange beschrijving

Wanneer u een opdracht invoert bij de opdrachtprompt, breekt PowerShell de opdrachttekst in een reeks segmenten met de naam tokens en bepaalt vervolgens hoe elk token moet worden geïnterpreteerd.

Als u bijvoorbeeld typt:

Write-Host book

PowerShell breekt de opdracht in twee tokens, Write-Host en book, en interpreteert elk token onafhankelijk met behulp van een van de twee primaire parseringsmodi: expressiemodus en argumentmodus.

Opmerking

Terwijl PowerShell de opdrachtinvoer parseert, probeert het de opdrachtnamen te vertalen naar cmdlets of uitvoerbare bestanden. Als de naam van een opdracht niet exact overeenkomt, wordt de opdracht in PowerShell als standaardwerkwoord gebruikt Get- . PowerShell parseert bijvoorbeeld Process als Get-Process. Het is niet raadzaam om deze functie te gebruiken om de volgende redenen:

  • Het is inefficiënt. Dit zorgt ervoor dat PowerShell meerdere keren zoekt.
  • Externe programma's met dezelfde naam worden als eerste opgelost, zodat u de beoogde cmdlet niet mag uitvoeren.
  • Get-Help en Get-Command herkennen geen werkwoordloze namen.

Expressiemodus

De expressiemodus is bedoeld voor het combineren van expressies, vereist voor het bewerken van waarden in een scripttaal. Expressies zijn weergaven van waarden in de PowerShell-syntaxis en kunnen eenvoudig of samengesteld zijn, bijvoorbeeld:

Letterlijke expressies zijn directe weergaven van hun waarden:

'hello'
32

Variabeleexpressies dragen de waarde van de variabele waarnaar wordt verwezen:

$x
$script:path

Operators combineren andere expressies voor evaluatie:

-12
-not $Quiet
3 + 7
$input.Length -gt 1
  • letterlijke tekenreeksen moeten tussen aanhalingstekens staan.
  • Getallen worden behandeld als numerieke waarden in plaats van als een reeks tekens (tenzij er een escape-teken is).
  • Operators, waaronder unaire operatoren zoals - en -not en binaire operatoren, zoals + en -gt, worden geïnterpreteerd als operatoren en passen hun respectieve bewerkingen toe op hun argumenten (operands).
  • Kenmerk- en conversie-expressies worden geparseerd als expressies en toegepast op onderliggende expressies, [int] '7'bijvoorbeeld .
  • Variabeleverwijzingen worden geëvalueerd op basis van hun waarden, maar splatting (d.w.z. het plakken van vooraf ingevulde parametersets) is verboden en veroorzaakt een parserfout.
  • Al het andere zal worden behandeld als een bevel dat moet worden aangeroepen.

Argument instellingen

Bij het parseren ziet PowerShell er eerst naar uit om invoer als een expressie te interpreteren. Maar wanneer er een aanroep van een opdracht wordt aangetroffen, wordt het parseren voortgezet in de argumentmodus. Als u argumenten hebt die spaties bevatten, zoals paden, moet u deze argumentwaarden tussen aanhalingstekens plaatsen.

De argumentmodus is ontworpen voor het parseren van argumenten en parameters voor opdrachten in een shell-omgeving. Alle invoer wordt behandeld als een uitbreidbare tekenreeks, tenzij er een van de volgende syntaxis wordt gebruikt:

  • Dollarteken ($) gevolgd door een variabelenaam begint een variabeleverwijzing, anders wordt het geïnterpreteerd als onderdeel van de uitvouwbare tekenreeks. De variabeleverwijzing kan toegang tot leden of indexering omvatten.

    • Aanvullende tekens na eenvoudige variabeleverwijzingen, zoals $HOME, worden als onderdeel van hetzelfde argument beschouwd. Plaats de naam van de variabele tussen accolades ({}) om deze te scheiden van de volgende tekens. Bijvoorbeeld: ${HOME}.
    • Wanneer de variabeleverwijzing ledentoegang bevat, wordt de eerste van eventuele extra tekens beschouwd als het begin van een nieuw argument. Bijvoorbeeld $HOME.Length-more resulteert in twee argumenten: de waarde van $HOME.Length en letterlijke tekenreeks -more.

  • Aanhalingstekens (' en ") beginnen tekenreeksen

  • Accolades ({}) markeren het begin van nieuwe scriptblokken

  • Komma's (,) introduceren lijsten die als matrices worden doorgegeven, behalve wanneer het aan te roepen commando een native toepassing is, in welk geval ze worden geïnterpreteerd als onderdeel van de uitbreidbare tekenreeks. Initiële, opeenvolgende of volgende komma's worden niet ondersteund.

  • Haakjes (()) beginnen met een nieuwe expressie

  • Subexpressie-operator ($()) begint een ingesloten expressie.

  • Het aanvankelijke @-teken (@) start syntaxis van expressies zoals splatting (@args), arrays (@(1,2,3)) en letterlijke hashtabelwaarden (@{a=1;b=2}).

  • (), $()en @() creëren aan het begin van een token een nieuwe parsingcontext die expressies of geneste opdrachten kan bevatten.

    • Wanneer er extra tekens worden gevolgd, wordt het eerste extra teken beschouwd als het begin van een nieuw, afzonderlijk argument.
    • Wanneer voorafgegaan door een letterlijke tekst zonder aanhalingstekens $() , begint deze als een uitbreidbare tekenreeks, () begint een nieuw argument dat een expressie is, en @() wordt het als letterlijk @ genomen met () het starten van een nieuw argument dat een expressie is.

  • Al het overige wordt behandeld als een uitbreidbare tekenreeks, behalve metatekens die nog steeds moeten worden geëscaped.

    • De metacharacters in de argumentmodus (tekens met speciale syntactische betekenis) zijn: <space> ' " ` , ; ( ) { } | & < > @ #. Van deze zijn < > @ # alleen speciaal aan het begin van een token.

  • Het stop-parsing-token (--%) verandert de interpretatie van alle resterende argumenten. Zie de sectie stopparseringstoken hieronder voor meer informatie.

Voorbeelden

De volgende tabel bevat verschillende voorbeelden van tokens die worden verwerkt in de expressiemodus en argumentmodus en de evaluatie van deze tokens. Voor deze voorbeelden is de waarde van de variabele $a4.

Voorbeeld Wijze Resultaat
2 Uitdrukking 2 (geheel getal)
`2 Uitdrukking "2" (commando)
Write-Output 2 Uitdrukking 2 (geheel getal)
2+2 Uitdrukking 4 (geheel getal)
Write-Output 2+2 Argumentatie "2+2" (tekenreeks)
Write-Output(2+2) Uitdrukking 4 (geheel getal)
$a Uitdrukking 4 (geheel getal)
Write-Output $a Uitdrukking 4 (geheel getal)
$a+2 Uitdrukking 6 (geheel getal)
Write-Output $a+2 Argumentatie "4+2" (tekenreeks)
$- Argumentatie "$-" (opdracht)
Write-Output $- Argumentatie "$-" (tekenreeks)
a$a Uitdrukking "a$a" (opdracht)
Write-Output a$a Argumentatie "a4" (tekenreeks)
a'$a' Uitdrukking "a$a" (opdracht)
Write-Output a'$a' Argumentatie a$a (tekenreeks)
a"$a" Uitdrukking "a$a" (opdracht)
Write-Output a"$a" Argumentatie "a4" (tekenreeks)
a$(2) Uitdrukking "a$(2)" (opdracht)
Write-Output a$(2) Argumentatie "a2" (tekenreeks)

Elk token kan worden geïnterpreteerd als een soort objecttype, zoals Booleaanse of tekenreeks. PowerShell probeert het objecttype van de expressie te bepalen. Het objecttype is afhankelijk van het type parameter dat een opdracht verwacht en of PowerShell weet hoe het argument moet worden geconverteerd naar het juiste type. In de volgende tabel ziet u verschillende voorbeelden van de typen die zijn toegewezen aan waarden die door de expressies worden geretourneerd.

Voorbeeld Wijze Resultaat
Write-Output !1 ruzie "!1" (tekenreeks)
Write-Output (!1) uitdrukking Onwaar (Booleaanse waarde)
Write-Output (2) uitdrukking 2 (geheel getal)
Set-Variable AB A,B ruzie 'A','B' (matrix)
CMD /CECHO A,B ruzie 'A,B' (tekenreeks)
CMD /CECHO $AB uitdrukking 'A B' (reeks)
CMD /CECHO :$AB ruzie ':A B' (tekenreeks)

Argumenten doorgeven aan systeemeigen opdrachten

Wanneer u systeemeigen opdrachten uitvoert vanuit PowerShell, worden de argumenten eerst geparseerd door PowerShell. De geparseerde argumenten worden vervolgens samengevoegd tot één tekenreeks, waarbij elke parameter wordt gescheiden door een spatie.

Met de volgende opdracht wordt bijvoorbeeld het icacls.exe-programma aanroepen.

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

Als u deze opdracht wilt uitvoeren in PowerShell 2.0, moet u escapetekens gebruiken om te voorkomen dat PowerShell de haakjes verkeerd interpreteert.

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

Het stop-parser-token

Vanaf PowerShell 3.0 kunt u het token stoppen met parseren van (--%) gebruiken om te voorkomen dat PowerShell invoer interpreteert als PowerShell-opdrachten of -expressies.

Opmerking

Het stop-parsing-token is alleen bedoeld voor gebruik op Windows-platforms.

Wanneer u een systeemeigen opdracht aanroept, plaatst u het stopparseringstoken vóór de programmaargumenten. Deze techniek is veel eenvoudiger dan het gebruik van escape-tekens om onjuiste interpretatie te voorkomen.

Wanneer een stopparseringstoken wordt aangetroffen, worden de resterende tekens in de regel in PowerShell als letterlijk beschouwd. De enige interpretatie die wordt uitgevoerd, is het vervangen van waarden voor omgevingsvariabelen die gebruikmaken van standaard Windows-notatie, zoals %USERPROFILE%.

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

PowerShell verzendt de volgende opdrachtreeks naar het icacls.exe-programma:

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

Het token voor het stoppen met parseren is alleen van kracht tot de volgende regelovergang of het pijplijnteken. U kunt een vervolgteken (`) niet gebruiken om het effect ervan uit te breiden of een scheidingsteken (;) gebruiken om het effect te beëindigen.

Anders dan %variable% verwijzingen naar omgevingsvariabelen, kunt u geen andere dynamische elementen in de opdracht insluiten. Het escapen van een % teken als %%, zoals je kunt doen in batchbestanden, wordt niet ondersteund. %<name>% tokens zijn steevast vergroot. Als <name> het token niet verwijst naar een gedefinieerde omgevingsvariabele, wordt het token doorgegeven via as-is.

U kunt geen stroomomleiding (zoals >file.txt) gebruiken, omdat ze letterlijk worden doorgegeven als argumenten voor de doelopdracht.

Argumenten doorgeven die aanhalingstekens bevatten

Sommige systeemeigen opdrachten verwachten argumenten die aanhalingstekens bevatten. Normaal gesproken verwijdert de opdrachtregelparsering van PowerShell het aanhalingsteken dat u hebt opgegeven. De geparseerde argumenten worden vervolgens samengevoegd tot één tekenreeks, waarbij elke parameter wordt gescheiden door een spatie. Deze tekenreeks wordt vervolgens toegewezen aan de eigenschap Argumenten van een ProcessStartInfo object. Aanhalingstekens binnen de tekenreeks moeten worden ontsnapt met extra aanhalingstekens of backslashtekens (\).

Opmerking

Het backslash-teken (\) wordt door PowerShell niet herkend als een escape-teken. Het is het escape-teken dat door de onderliggende API wordt gebruikt voor ProcessStartInfo.Arguments.

Zie de documentatie voor ProcessStartInfo.Arguments voor meer informatie over de escape-vereisten.

De volgende voorbeelden met behulp van de TestExe.exe tool. Deze tool wordt gebruikt door de Pester-tests in de PowerShell-bronrepo. Het doel van deze voorbeelden is om het mappad "C:\Program Files (x86)\Microsoft\" door te geven aan een systeemeigen opdracht, zodat het pad als een aanhalingstekenreeks is ontvangen.

De parameter echoargs van TestExe geeft de waarden weer die zijn ontvangen als argumenten voor het uitvoerbare bestand. U kunt dit hulpprogramma gebruiken om te controleren of u de tekens in uw argumenten correct hebt ontsnapt.

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

De uitvoer is hetzelfde voor alle voorbeelden:

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

U kunt TestExe bouwen vanuit de broncode. Zie TestExe.

Argumenten doorgeven aan PowerShell-opdrachten

Vanaf PowerShell 3.0 kunt u het end-of-parameters token (--) gebruiken om te voorkomen dat PowerShell invoer interpreteert als PowerShell-parameters. Dit is een conventie die is opgegeven in de POSIX Shell- en Utilities-specificatie.

Het token einde van parameters (--) geeft aan dat alle argumenten die erop volgen, moeten worden doorgegeven in hun werkelijke vorm alsof er dubbele aanhalingstekens om hen heen staan. Als u bijvoorbeeld -- gebruikt, kunt u de tekenreeks uitvoeren -InputObject zonder aanhalingstekens te gebruiken of als parameter te laten interpreteren:

Write-Output -- -InputObject

-InputObject

In tegenstelling tot het stop-parsen-token (--%), kunnen alle waarden na het ---token door PowerShell worden geïnterpreteerd als uitdrukkingen.

Write-Output -- -InputObject $env:PROCESSOR_ARCHITECTURE

-InputObject
AMD64

Dit gedrag is alleen van toepassing op PowerShell-opdrachten. Als u het -- token gebruikt bij het aanroepen van een externe opdracht, wordt de -- tekenreeks als argument doorgegeven aan die opdracht.

TestExe -echoargs -a -b -- -c

De uitvoer laat zien dat -- wordt doorgegeven als een argument aan TestExe.

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

Zie ook

  • Laatst bijgewerkt om