about_Parsing

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	Argumentum	"!1" (sztring)
Write-Output (!1)	Kifejezés	Hamis (logikai)
Write-Output (2)	Kifejezés	2 (egész szám)
Set-Variable AB A,B	Argumentum	'A','B' (tömb)
CMD /CECHO A,B	Argumentum	"A,B" (sztring)
CMD /CECHO $AB	Kifejezés	"A B" (tömb)
CMD /CECHO :$AB	Argumentum	':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 7.3 módosította a parancssor natív parancsokhoz való elemzésének módját.

Figyelemfelhívás

Az új viselkedés a Windows PowerShell 5.1 viselkedésének kompatibilitástörő változása . Ez megszakíthatja a szkripteket és az automatizálást, amelyek a natív alkalmazások meghívása során felmerülő különböző problémákat megkerülik. A stop-parsing token (--%) vagy a Start-Process parancsmag használatával elkerülheti a natív argumentumok átadását, ha szükséges.

Ezt a viselkedést az új $PSNativeCommandArgumentPassing beállításváltozó vezérli. Ez a változó lehetővé teszi, hogy futásidőben válassza ki a viselkedést. Az érvényes értékek a következők Legacy: , Standardés Windows. Az alapértelmezett viselkedés platformspecifikus. Windows-platformokon az alapértelmezett beállítás, Windows a nem Windows-platformok pedig alapértelmezés szerint a Standard.

Legacy a történelmi viselkedés. A viselkedés Windows és Standard a mód ugyanaz, kivéve, Windows ha a következő fájlok meghívásai automatikusan használják az Legacy átadott stílusargumentumot.

• cmd.exe
• cscript.exe
• wscript.exe
• végződés: .bat
• végződés: .cmd
• végződés: .js
• végződés: .vbs
• végződés: .wsf

Ha az $PSNativeCommandArgumentPassing érték vagy LegacyStandarda beállítás, az elemző nem ellenőrzi ezeket a fájlokat.

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.

A módosítás által elérhetővé tett új viselkedések:

• Az idézőjeleket tartalmazó literális vagy bővíthető sztringek mostantól megmaradnak:

  PS> $a = 'a" "b'
  PS> TestExe -echoargs $a 'c" "d' e" "f
  Arg 0 is <a" "b>
  Arg 1 is <c" "d>
  Arg 2 is <e f>
  

• Az argumentumként üres sztringek mostantól megmaradnak:

  PS> TestExe -echoargs '' a b ''
  Arg 0 is <>
  Arg 1 is <a>
  Arg 2 is <b>
  Arg 3 is <>
  

Ezeknek a példáknak a célja, hogy a címtár elérési útját (szóközökkel és idézőjelekkel) "C:\Program Files (x86)\Microsoft\" egy natív parancsnak adja át, hogy idézőjeles sztringként kapja meg az elérési utat.

Standard A Windows következő példák vagy módban a várt eredmények a következők:

TestExe -echoargs """${env:ProgramFiles(x86)}\Microsoft\"""
TestExe -echoargs '"C:\Program Files (x86)\Microsoft\"'

Ha ugyanazt az eredményt Legacy szeretné megkapni módban, el kell menekülnie az idézőjelek elől, vagy a stop-parsing tokent (--%):

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

Feljegyzés

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

A PowerShell 7.3 emellett lehetővé tette a natív parancsok paraméterkötésének nyomon követését is. További információ: Trace-Command.

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>

Lásd még

• about_Command_Syntax