about_Parsing

Artikel
05/08/2024

Korte beschrijving

Hierin wordt beschreven hoe PowerShell opdrachten parseert.

Lange beschrijving

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

Als u bijvoorbeeld typt:

Write-Host book

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

Notitie

Terwijl PowerShell opdrachtinvoer parseert, wordt geprobeerd de opdrachtnamen om te lossen naar cmdlets of systeemeigen uitvoerbare bestanden. Als een opdrachtnaam geen exacte overeenkomst heeft, wordt powerShell als standaardwerkwoord voor de opdracht gebruikt Get- . PowerShell parseert Service bijvoorbeeld als Get-Service. 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 eerst omgezet, dus u kunt de beoogde cmdlet niet uitvoeren.
Get-Help en Get-Command herkent geen werkwoordloze namen.
De opdrachtnaam kan een gereserveerd woord of een taalwoord zijn. Process is beide, en kan niet worden omgezet in Get-Process.

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 een escape-teken).
Operators, waaronder unaire operators zoals - en -not binaire operatoren zoals + en -gt, worden geïnterpreteerd als operators en passen hun respectieve bewerkingen toe op hun argumenten (operanden).
Kenmerk- en conversieexpressies worden geparseerd als expressies en toegepast op onderliggende expressies. Voorbeeld: [int] '7'.
Variabele verwijzingen worden geëvalueerd naar hun waarden, maar splatting is verboden en veroorzaakt een parserfout.
Iets anders wordt behandeld als een opdracht die moet worden aangeroepen.

Argumentmodus

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 variabelereferentie, anders wordt dit geïnterpreteerd als onderdeel van de uitbreidbare tekenreeks. De variabeleverwijzing kan toegang tot leden of indexering omvatten.
- Aanvullende tekens na eenvoudige variabeleverwijzingen, zoals $HOME, worden beschouwd als onderdeel van hetzelfde argument. Plaats de naam van de variabele tussen accolades ({}) om deze te scheiden van volgende tekens. Bijvoorbeeld: ${HOME}.
- Wanneer de variabelereferentie lidtoegang bevat, wordt de eerste van eventuele extra tekens beschouwd als het begin van een nieuw argument. Resulteert bijvoorbeeld $HOME.Length-more in twee argumenten: de waarde van $HOME.Length en de letterlijke tekenreeks -more.
Aanhalingstekens (' en ") beginnen tekenreeksen
Accolades ({}) beginnen met een nieuw scriptblok
Komma's (,) introduceren lijsten die als matrices worden doorgegeven, tenzij de opdracht die wordt aangeroepen een systeemeigen toepassing is, in welk geval ze worden geïnterpreteerd als onderdeel van de uitbreidbare tekenreeks. Initiële, opeenvolgende of volgkomma's worden niet ondersteund.
Haakjes (()) beginnen met een nieuwe expressie
De operator Voor subexpressie ($()) wordt een ingesloten expressie gestart
Initieel bij teken (@) begint expressiesyntaxis zoals splatting (@args), matrices (@(1,2,3)) en letterlijke hashtabellen (@{a=1;b=2}).
(), $()en @() aan het begin van een token maakt u een nieuwe parseringscontext 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 een letterlijke uitbreidbare tekenreeks $() voorafgaat aan een niet-aanhalingsteken, () begint u een nieuw argument dat een expressie is en @() wordt deze als letterlijk @ beschouwd bij () het starten van een nieuw argument dat een expressie is.
Alles anders wordt behandeld als een uitbreidbare tekenreeks, behalve metatekens die nog steeds ontsnappen nodig hebben. Zie Speciale tekens verwerken.
- De metacharacters in de argumentmodus (tekens met speciale syntactische betekenis) zijn: <space> ' " ` , ; ( ) { } | & < > @ #. Van deze, < > @ # zijn alleen speciaal aan het begin van een token.
Het token voor stoppen parseren (--%) wijzigt de interpretatie van alle resterende argumenten. Zie de sectie stop-parsing-token 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 4de waarde van de variabele $a .

Opmerking	Modus	Resultaat
`2`	Expression	2 (geheel getal)
`2	Expression	"2" (opdracht)
`Write-Output 2`	Expression	2 (geheel getal)
`2+2`	Expression	4 (geheel getal)
`Write-Output 2+2`	Argument	"2+2" (tekenreeks)
`Write-Output(2+2)`	Expression	4 (geheel getal)
`$a`	Expression	4 (geheel getal)
`Write-Output $a`	Expression	4 (geheel getal)
`$a+2`	Expression	6 (geheel getal)
`Write-Output $a+2`	Argument	"4+2" (tekenreeks)
`$-`	Argument	"$-" (opdracht)
`Write-Output $-`	Argument	"$-" (tekenreeks)
`a$a`	Expression	"a$a" (opdracht)
`Write-Output a$a`	Argument	"a4" (tekenreeks)
`a'$a'`	Expression	"a$a" (opdracht)
`Write-Output a'$a'`	Argument	"a$a" (tekenreeks)
`a"$a"`	Expression	"a$a" (opdracht)
`Write-Output a"$a"`	Argument	"a4" (tekenreeks)
`a$(2)`	Expression	"a$(2)" (opdracht)
`Write-Output a$(2)`	Argument	"a2" (tekenreeks)

Elk token kan worden geïnterpreteerd als een soort objecttype, zoals Booleaanse waarde 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.

Opmerking	Modus	Resultaat
`Write-Output !1`	argument	"!1" (tekenreeks)
`Write-Output (!1)`	uitdrukking	Onwaar (Booleaanse waarde)
`Write-Output (2)`	uitdrukking	2 (geheel getal)
`Set-Variable AB A,B`	argument	'A','B' (matrix)
`CMD /CECHO A,B`	argument	'A,B' (tekenreeks)
`CMD /CECHO $AB`	uitdrukking	A B (matrix)
`CMD /CECHO :$AB`	argument	':A B' (tekenreeks)

Afhandeling van speciale tekens

Het backtickteken (`) kan worden gebruikt om een speciaal teken in een expressie te ontsnappen. Dit is het handigst voor het ontsnappen van de metatekens in de argumentmodus die u wilt gebruiken als letterlijke tekens in plaats van als metacharacter. Als u bijvoorbeeld het dollarteken ($) wilt gebruiken als een letterlijke waarde in een uitbreidbare tekenreeks:

"The value of `$ErrorActionPreference is '$ErrorActionPreference'."

The value of $ErrorActionPreference is 'Continue'.

Regelvervolging

Het backtickteken kan ook worden gebruikt aan het einde van een regel, zodat u de invoer op de volgende regel kunt voortzetten. Dit is de leesbaarheid van een opdracht die verschillende parameters met lange namen en argumentwaarden gebruikt. Voorbeeld:

New-AzVm `
    -ResourceGroupName "myResourceGroupVM" `
    -Name "myVM" `
    -Location "EastUS" `
    -VirtualNetworkName "myVnet" `
    -SubnetName "mySubnet" `
    -SecurityGroupName "myNetworkSecurityGroup" `
    -PublicIpAddressName "myPublicIpAddress" `
    -Credential $cred

U moet echter voorkomen dat u regelvervolging gebruikt.

De backticktekens kunnen moeilijk te zien en gemakkelijk te vergeten zijn.
Een extra spatie na de backtick breekt de regelvervolging af. Omdat de ruimte moeilijk te zien is, kan het lastig zijn om de fout te vinden.

PowerShell biedt verschillende manieren om lijnen te verbreken op natuurlijke punten in de syntaxis.

Na sluistekens (|)
Na binaire operatoren (+, -, -eqenzovoort)
Na komma's (,) in een matrix
Na het openen van tekens zoals [, , {(

Voor een grote parameterset gebruikt u in plaats daarvan splatting. Voorbeeld:

$parameters = @{
    ResourceGroupName = "myResourceGroupVM"
    Name = "myVM"
    Location = "EastUS"
    VirtualNetworkName = "myVnet"
    SubnetName = "mySubnet"
    SecurityGroupName = "myNetworkSecurityGroup"
    PublicIpAddressName = "myPublicIpAddress"
    Credential = $cred
}
New-AzVm @parameters

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 token voor stoppen parseren

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

Notitie

Het token voor stoppen parseren is alleen bedoeld voor het gebruik van systeemeigen opdrachten 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 er een stopparseringstoken wordt tegengekomen, worden de resterende tekens in de regel in PowerShell als letterlijk behandeld. 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 stoppen parseren is alleen van kracht tot het volgende nieuwe regel- of pijplijnteken. U kunt het vervolgteken regel (`) niet gebruiken om het effect ervan uit te breiden of een opdrachtscheidingsteken (;) te gebruiken om het effect ervan te beëindigen.

%variable% Behalve verwijzingen naar omgevingsvariabelen kunt u geen andere dynamische elementen insluiten in de opdracht. Ontsnappen aan een % teken als %%, zoals u in batchbestanden kunt doen, wordt niet ondersteund. %<name>% tokens worden altijd uitgevouwen. Als <name> dit niet verwijst naar een gedefinieerde omgevingsvariabele, wordt het token doorgegeven als zodanig.

U kunt streamomleiding (zoals >file.txt) niet gebruiken omdat ze worden doorgegeven als argumenten aan de doelopdracht.

In het volgende voorbeeld voert de eerste stap een opdracht uit zonder het token voor stoppen-parseren te gebruiken. PowerShell evalueert de aanhalingstekenreeks en geeft de waarde (zonder aanhalingstekens) cmd.exedoor, wat resulteert in een fout.

PS> cmd /c echo "a|b"
'b' is not recognized as an internal or external command,
operable program or batch file.
PS> cmd /c --% echo "a|b"
"a|b"

Notitie

Het token voor stoppen parseren is niet nodig bij het gebruik van PowerShell-cmdlets. Het kan echter handig zijn om argumenten door te geven aan een PowerShell-functie die is ontworpen om een systeemeigen opdracht aan te roepen met deze argumenten.

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 (\).

Notitie

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

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

Notitie

In de volgende voorbeelden wordt het TestExe.exe hulpprogramma gebruikt. U kunt bouwen TestExe vanuit de broncode. Zie TestExe in de PowerShell-bronopslagplaats.

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 --% """%ProgramFiles(x86)%\Microsoft\\""

De uitvoer is hetzelfde voor alle voorbeelden:

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

Argumenten doorgeven aan PowerShell-opdrachten

Vanaf PowerShell 3.0 kunt u het token end-of-parameters (--) 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 end-of-parameters

Het token einde van parameters (--) geeft aan dat alle argumenten die erop volgen, moeten worden doorgegeven in hun werkelijke vorm alsof er dubbele aanhalingstekens rond deze aanhalingstekens zijn geplaatst. U kunt bijvoorbeeld -- de tekenreeks -InputObject uitvoeren zonder aanhalingstekens te gebruiken of deze als parameter te laten interpreteren:

Write-Output -- -InputObject

-InputObject

In tegenstelling tot het token voor stoppen parseren (--%) kunnen alle waarden na het -- token worden geïnterpreteerd als expressies door PowerShell.

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 doorgegeven als een argument voor die opdracht.

TestExe -echoargs -a -b -- -c

In de uitvoer ziet u dat -- deze wordt doorgegeven als argument aan TestExe.

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

Tilde (~)

Het tilde-teken (~) heeft een speciale betekenis in PowerShell. Wanneer het wordt gebruikt met PowerShell-opdrachten aan het begin van een pad, wordt het tilde-teken uitgebreid naar de basismap van de gebruiker. Als het tilde-teken ergens anders in een pad wordt gebruikt, wordt het beschouwd als een letterlijk teken.

PS D:\temp> $PWD

Path
----
D:\temp

PS D:\temp> Set-Location ~
PS C:\Users\user2> $PWD

Path
----
C:\Users\user2

In dit voorbeeld wordt een tekenreeks verwacht met de parameter Name van de New-Item parameter. Het tilde-teken wordt behandeld als een letterlijk teken. Als u wilt overschakelen naar de zojuist gemaakte map, moet u het pad kwalificeren met het tilde-teken.

PS D:\temp> Set-Location ~
PS C:\Users\user2> New-Item -Type Directory -Name ~

    Directory: C:\Users\user2

Mode                 LastWriteTime         Length Name
----                 -------------         ------ ----
d----            5/6/2024  2:08 PM                ~

PS C:\Users\user2> Set-Location ~
PS C:\Users\user2> Set-Location .\~
PS C:\Users\user2\~> $PWD

Path
----
C:\Users\user2\~

Wanneer u het tilde-teken met systeemeigen opdrachten gebruikt, geeft PowerShell de tilde door als een letterlijk teken. Het gebruik van de tilde in een pad veroorzaakt fouten voor systeemeigen opdrachten in Windows die het tilde-teken niet ondersteunen.

PS D:\temp> $PWD

Path
----
D:\temp

PS D:\temp> Get-Item ~\repocache.clixml

    Directory: C:\Users\user2

Mode                 LastWriteTime         Length Name
----                 -------------         ------ ----
-a---           4/29/2024  3:42 PM          88177 repocache.clixml

PS D:\temp> more.com ~\repocache.clixml
Cannot access file D:\temp\~\repocache.clixml

Zie ook

about_Command_Syntax

Delen via

about_Parsing

Korte beschrijving

Lange beschrijving

Expressiemodus

Argumentmodus

Voorbeelden

Afhandeling van speciale tekens

Regelvervolging

Argumenten doorgeven aan systeemeigen opdrachten

Het token voor stoppen parseren

Argumenten doorgeven die aanhalingstekens bevatten

Argumenten doorgeven aan PowerShell-opdrachten

Het token end-of-parameters

Tilde (~)

Zie ook

Aanvullende resources