about_Parsing

Cikk
05/08/2024

Rövid leírás

Ismerteti, hogyan elemzi a PowerShell a parancsokat.

Hosszú leírás

Amikor parancsot ad meg a parancssorban, a PowerShell a parancsszöveget jogkivonatok nevű szegmensek sorozatára bontja, majd meghatározza az egyes jogkivonatok értelmezésének módját.

Ha például a következőt írja be:

Write-Host book

A PowerShell két jogkivonatra bontja a parancsot, Write-Host és bookegymástól függetlenül értelmezi az egyes jogkivonatokat két fő elemzési mód egyikével: a kifejezésmóddal és az argumentum móddal.

Feljegyzés

Amikor a PowerShell elemzi a parancs bemenetét, parancsmagokra vagy natív végrehajtható fájlokra próbálja feloldani a parancsneveket. Ha egy parancsnévnek nincs pontos egyezése, a PowerShell alapértelmezés szerint a parancsra van elővetve Get- . A PowerShell például a következőképpen elemzi Service a következőt Get-Service: . A következő okok miatt nem ajánlott ezt a funkciót használni:

Nem hatékony. Emiatt a PowerShell többször is keres.
Az azonos nevű külső programok először feloldódnak, így előfordulhat, hogy nem hajtja végre a kívánt parancsmagot.
Get-Help és Get-Command ne ismerje fel az igék nélküli neveket.
A parancs neve lehet fenntartott szó vagy nyelvi kulcsszó. Processmindkettő, és nem oldható fel.Get-Process

Kifejezésmód

A kifejezésmód a kifejezések kombinálására szolgál, amely a szkriptnyelvben az értékkezeléshez szükséges. A kifejezések a PowerShell szintaxisában szereplő értékek ábrázolásai, amelyek lehetnek egyszerűek vagy összetettek, például:

A literális kifejezések az értékük közvetlen ábrázolásai:

'hello'
32

A változókifejezések a hivatkozott változó értékét hordozzák:

$x
$script:path

Az operátorok más kifejezéseket is kombinálnak a kiértékeléshez:

-12
-not $Quiet
3 + 7
$input.Length -gt 1

A karaktersztring literáljait idézőjelekben kell tárolni.
A számok számértékekként vannak kezelve, nem pedig karaktersorozatként (kivéve, ha nem szöknek meg).
Az operátorokat, beleértve a nem szereplő operátorokat - , -not valamint a bináris operátorokat és hasonlókat + -gt, operátorként értelmezik, és az argumentumaikra (operandusaikra) alkalmazzák a megfelelő műveleteket.
Az attribútum- és konverziós kifejezések kifejezésként vannak elemezve, és az alárendelt kifejezésekre lesznek alkalmazva. Például: [int] '7'
A változóhivatkozások kiértékelése az értékükre történik, de a splatting tiltott, és elemzési hibát okoz.
A rendszer minden mást meghívandó parancsként kezel.

Argumentum mód

Elemzéskor a PowerShell először kifejezésként értelmezi a bemenetet. Ha azonban parancshívás történik, az elemzés argumentum módban folytatódik. Ha olyan argumentumokkal rendelkezik, amelyek szóközöket, például elérési utakat tartalmaznak, akkor ezeket az argumentumértékeket idézőjelekbe kell ágyaznia.

Az argumentum mód a rendszerhéj-környezet parancsainak argumentumainak és paramétereinek elemzésére szolgál. Az összes bemenet kibontható sztringként lesz kezelve, kivéve, ha az alábbi szintaxisok egyikét használja:

A dollárjel ($) és a változó neve változóhivatkozást kezd, ellenkező esetben a függvény a bővíthető sztring részeként értelmezi. A változóhivatkozás tartalmazhat taghozzáférést vagy indexelést.
- Az egyszerű változóhivatkozásokat követő további karakterek, például $HOMEa , ugyanazon argumentum részét képezik. A változó nevét kapcsos zárójelekbe ({}) kell befoglalnia, hogy elválasztsa a következő karakterektől. Például: ${HOME}.
- Ha a változóhivatkozás taghozzáférést tartalmaz, a további karakterek közül az első lesz az új argumentum kezdete. Például $HOME.Length-more két argumentumot eredményez: az érték és $HOME.Length a sztringkonstans -more.
Idézőjelek (' és ") kezdő sztringek
Kapcsos zárójelek ({}) új szkriptblokkok indítása
A vesszők (,) tömbökként átadott listákat vezetnek be, kivéve, ha a meghívandó parancs natív alkalmazás, amely esetben azokat a bővíthető sztring részeként értelmezi a rendszer. A kezdeti, egymást követő vagy záró vesszők nem támogatottak.
Zárójelek (()) új kifejezés indítása
A subexpression operátor ($()) beágyazott kifejezést kezd
Az inicializálás (@) elkezdi a kifejezés szintaxisát, például splatting (@args), tömbök (@(1,2,3)) és kivonattábla-literálok (@{a=1;b=2}).
(), $()majd @() a jogkivonat elején hozzon létre egy új elemzési környezetet, amely kifejezéseket vagy beágyazott parancsokat tartalmazhat.
- Ha további karaktereket követ, az első további karakter egy új, különálló argumentum kezdetének számít.
- Ha egy nem kvótált literál $() úgy működik, mint egy bővíthető sztring, () elindít egy új argumentumot, amely egy kifejezés, és @() konstansként @ veszi fel egy kifejezésnek számító új argumentum elindításával () .
Minden mást bővíthető sztringként kezelünk, kivéve azokat a metakaraktereket, amelyek még menekülni kell. Lásd: Speciális karakterek kezelése.
- Az argumentummódú metadiagramok (speciális szintaktikai jelentésű karakterek) a következők: <space> ' " ` , ; ( ) { } | & < > @ #. Ezek < > @ # közül csak a token elején különlegesek.
A stop-parsing token (--%) megváltoztatja az összes többi argumentum értelmezését. További információ: stop-parsing token section below.

Példák

Az alábbi táblázat számos példát mutat be a kifejezés- és argumentum módban feldolgozott jogkivonatokra, valamint a jogkivonatok kiértékeléséhez. Ezekben a példákban a változó $a értéke .4

Példa	Mód	Eredmény
`2`	Expression	2 (egész szám)
`2	Expression	"2" (parancs)
`Write-Output 2`	Expression	2 (egész szám)
`2+2`	Expression	4 (egész szám)
`Write-Output 2+2`	Argumentum	"2+2" (sztring)
`Write-Output(2+2)`	Expression	4 (egész szám)
`$a`	Expression	4 (egész szám)
`Write-Output $a`	Expression	4 (egész szám)
`$a+2`	Expression	6 (egész szám)
`Write-Output $a+2`	Argumentum	"4+2" (sztring)
`$-`	Argumentum	"$-" (parancs)
`Write-Output $-`	Argumentum	"$-" (sztring)
`a$a`	Expression	"a$a" (parancs)
`Write-Output a$a`	Argumentum	"a4" (sztring)
`a'$a'`	Expression	"a$a" (parancs)
`Write-Output a'$a'`	Argumentum	"a$a" (sztring)
`a"$a"`	Expression	"a$a" (parancs)
`Write-Output a"$a"`	Argumentum	"a4" (sztring)
`a$(2)`	Expression	"a$(2)" (parancs)
`Write-Output a$(2)`	Argumentum	"a2" (sztring)

Minden jogkivonat értelmezhető valamilyen objektumtípusként, például logikai vagy sztringként. A PowerShell megkísérli meghatározni a kifejezés objektumtípusát. Az objektum típusa attól függ, hogy a parancs milyen típusú paramétert vár el, és hogy a PowerShell tudja-e, hogyan konvertálja az argumentumot a megfelelő típusra. Az alábbi táblázat több példát mutat be a kifejezések által visszaadott értékekhez rendelt típusokra.

Példa	Mód	Eredmény
`Write-Output !1`	vita	"!1" (sztring)
`Write-Output (!1)`	kifejezés	Hamis (logikai)
`Write-Output (2)`	kifejezés	2 (egész szám)
`Set-Variable AB A,B`	vita	'A','B' (tömb)
`CMD /CECHO A,B`	vita	"A,B" (sztring)
`CMD /CECHO $AB`	kifejezés	"A B" (tömb)
`CMD /CECHO :$AB`	vita	':A B' (sztring)

Speciális karakterek kezelése

A backtick karakter (`) a kifejezés bármely speciális karakterének kivédésére használható. Ez a leginkább hasznos az argumentum módú metacharacterek elől, amelyeket nem metacharacterként, hanem literális karakterként szeretne használni. Ha például a dollárjelet ($) literálként szeretné használni egy bővíthető sztringben:

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

The value of $ErrorActionPreference is 'Continue'.

Sor folytatása

A háttér karakter a sor végén is használható, így a következő sorban folytathatja a bemenetet. Ez javítja egy olyan parancs olvashatóságát, amely több hosszú nevet és argumentumértéket tartalmazó paramétert használ. Példa:

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

Azonban ne használjon sor-folytatást.

A háttérkarakterek nehezen láthatók és könnyen felejthetők el.
Egy további tér, miután a háttérrendszer megszakítja a vonal folytatását. Mivel a hely nehezen látható, nehéz lehet megtalálni a hibát.

A PowerShell többféle módon is megszakítja a vonalakat a szintaxis természetes pontjain.

Csőkarakterek után (|)
Bináris operátorok (+, , -eq-stb.) után
Vesszők (,) után egy tömbben
Az olyan karakterek megnyitása után, mint a [, {(

Nagy paraméterkészlet esetén használjon splattingot. Példa:

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

Argumentumok átadása natív parancsoknak

Ha natív parancsokat futtat a PowerShellből, az argumentumokat először a PowerShell elemzi. Az elemzett argumentumok ezután egyetlen sztringbe lesznek illesztve, és mindegyik paramétert szóköz választja el egymástól.

A következő parancs például meghívja a icacls.exe programot.

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

A parancs PowerShell 2.0-s futtatásához menekülő karaktereket kell használnia ahhoz, hogy a PowerShell ne értelmezze félre a zárójeleket.

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

A stop-parsing token

A PowerShell 3.0-tól kezdve a stop-parsing (--%) jogkivonat használatával megakadályozhatja, hogy a PowerShell PowerShell-parancsok vagy kifejezésekként értelmezze a bemenetet.

Feljegyzés

A stop-parsing token csak natív parancsok használatára szolgál Windows-platformokon.

Natív parancs meghívásakor helyezze a stop-parsing tokent a programargumentumok elé. Ez a technika sokkal egyszerűbb, mint a menekülési karakterek használata a félreértelmezés megakadályozása érdekében.

Amikor leállítási jogkivonattal találkozik, a PowerShell a sor többi karakterét konstansként kezeli. Az egyetlen értelmezés, amelyet végrehajt, az a szabványos Windows-jelölést használó környezeti változók értékeinek helyettesítése, például %USERPROFILE%.

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

A PowerShell a következő parancssztringet küldi a icacls.exe programnak:

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

A stop-parsing token csak a következő új vonal vagy folyamat karakterig érvényes. Nem használhatja a vonal folytatási karakterét (`) a hatás kiterjesztéséhez, és nem használhat parancselválasztót (;) a hatás megszüntetéséhez.

A környezeti változókra mutató hivatkozásokon kívül %variable% nem ágyazhat be más dinamikus elemeket a parancsba. A karaktert %%a kötegelt fájlokban való elszabadítás % nem támogatja. %<name>% a jogkivonatok mindig ki vannak bontva. Ha <name> nem hivatkozik definiált környezeti változóra, a jogkivonat át lesz adva.

A stream átirányítása (például >file.txt) nem használható, mert a célparancs argumentumként verbatimként továbbítja őket.

Az alábbi példában az első lépés a stop-parsing jogkivonat használata nélkül futtat egy parancsot. A PowerShell kiértékeli az idézett sztringet, és átadja az értéket (idézőjelek nélkül), cmd.exeami hibát eredményez.

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"

Feljegyzés

A stop-parsing tokenre nincs szükség PowerShell-parancsmagok használatakor. Hasznos lehet azonban argumentumokat átadni egy Olyan PowerShell-függvénynek, amely úgy van kialakítva, hogy natív parancsot hívjon meg ezekkel az argumentumokkal.

Idézőjeleket tartalmazó argumentumok átadása

Egyes natív parancsok idézőjeleket tartalmazó argumentumokat várnak. A PowerShell parancssori elemzése általában eltávolítja a megadott idézőjelet. Az elemzett argumentumok ezután egyetlen sztringbe lesznek illesztve, és mindegyik paramétert szóköz választja el egymástól. Ez a sztring ezután hozzá lesz rendelve egy ProcessStartInfo objektum Argumentumok tulajdonságához. A sztringen belüli idézőjeleket extra idézőjelek vagy fordított perjel (\) karakterekkel kell feloldani.

Feljegyzés

A Fordított perjel (\) karaktert a PowerShell nem ismeri fel menekülési karakterként. Ez a mögöttes API által használt escape karakter.ProcessStartInfo.Arguments

A feloldás követelményeiről további információt a ProcessStartInfo.Arguments dokumentációjában talál.

Feljegyzés

Az alábbi példák az TestExe.exe eszközt használják. A forráskódból építhet TestExe . Lásd: TestExe a PowerShell-forrásadattárban.

Ezeknek a példáknak a célja, hogy a címtár elérési útját "C:\Program Files (x86)\Microsoft\" egy natív parancsnak adja át, hogy az idézett sztringként kapja meg az elérési utat.

Az echoargs paraméter TestExe a végrehajtható fájl argumentumaként kapott értékeket jeleníti meg. Ezzel az eszközzel ellenőrizheti, hogy megfelelően elkerülte-e az argumentumokban szereplő karaktereket.

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

A kimenet minden példában ugyanaz:

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

Argumentumok továbbítása PowerShell-parancsoknak

A PowerShell 3.0-tól kezdve a paraméterek végi jogkivonatával (--) megakadályozhatja, hogy a PowerShell PowerShell-paraméterekként értelmezze a bemenetet. Ez egy konvenció, amelyet a POSIX Shell és a Utilities specifikáció határoz meg.

A paraméterek végének jogkivonata

A paraméterek záró jogkivonata (--) azt jelzi, hogy az azt követő összes argumentumot a tényleges formájukban kell átadni, mintha dupla idézőjelek lettek volna elhelyezve körülöttük. A használatával -- például idézőjelek nélkül is kiadhatja a sztringet -InputObject , vagy paraméterként értelmezheti:

Write-Output -- -InputObject

-InputObject

A stop-parsing (--%) jogkivonattól eltérően a jogkivonatot követő értékek kifejezésként értelmezhetők a -- PowerShellben.

Write-Output -- -InputObject $env:PROCESSOR_ARCHITECTURE

-InputObject
AMD64

Ez a viselkedés csak a PowerShell-parancsokra vonatkozik. Ha külső parancs meghívásakor használja a -- jogkivonatot, a -- sztring argumentumként lesz átadva a parancsnak.

TestExe -echoargs -a -b -- -c

A kimenet azt mutatja, hogy -- a függvény argumentumként van átadva a következőnek TestExe: .

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

Tilde (~)

A tilde karakter (~) különleges jelentéssel bír a PowerShellben. Ha az elérési út elején PowerShell-parancsokkal használják, a tilde karakter ki lesz bontva a felhasználó kezdőlapjára. Ha a tilde karaktert bárhol máshol használják az elérési úton, akkor a rendszer konstans karakterként kezeli.

PS D:\temp> $PWD

Path
----
D:\temp

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

Path
----
C:\Users\user2

Ebben a példában a név paraméter New-Item egy sztringet vár. A tilde karaktert a rendszer literális karakterként kezeli. Az újonnan létrehozott könyvtárra való váltáshoz az elérési utat a tilde karakterrel kell minősíteni.

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

Ha natív parancsokkal használja a tilde karaktert, a PowerShell konstans karakterként adja át a tilde karaktert. A tilde elérési útban való használata hibákat okoz a windowsos natív parancsok esetében, amelyek nem támogatják a tilde karaktert.

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

Lásd még

about_Command_Syntax

Megosztás a következőn keresztül:

about_Parsing

Rövid leírás

Hosszú leírás

Kifejezésmód

Argumentum mód

Példák

Speciális karakterek kezelése

Sor folytatása

Argumentumok átadása natív parancsoknak

A stop-parsing token

Idézőjeleket tartalmazó argumentumok átadása

Argumentumok továbbítása PowerShell-parancsoknak

A paraméterek végének jogkivonata

Tilde (~)

Lásd még

További források