a feldolgozásról

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 tokenek é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 book, és egymá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.

Megjegyzé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ésként hozzáfűzi a Get--t a parancshoz, mint alapértelmezett igét. Például a PowerShell a Service értéket Get-Service-ként elemzi. A következő okok miatt nem ajánlott ezt a funkciót használni:

• Nem hatékony. Emiatt a PowerShell többszöri kereséseket végez.
• Az azonos nevű külső programok először kerülnek kezelésre, így előfordulhat, hogy nem futtatja a kívánt cmdletet.
• Get-Help és Get-Command nem ismerik fel az igék nélküli neveket.
• A parancs neve lehet fenntartott szó vagy nyelvi kulcsszó. Process mindkettő, és nem lehet Get-Process-hez kapcsolni.

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

• Karakterlánc literáloknak idézőjelek között kell lenniük.
• A számok nem karaktersorozatként, hanem számértékként kezelik (kivéve, ha nem szökik meg).
• Operátorok, beleértve az olyan nem szereplő operátorokat, mint a -, a -not és a bináris operátorok, például a + és a -gt, operátorként értelmezik, és az argumentumaikra (operandusaikra) alkalmazzák a megfelelő műveleteket.
• 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'.
• változóhivatkozások kiértékelése az értékükre történik, de splatting tilos, é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-üzemmód a shell 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 ($), amelyet egy változónév követ, egy változóhivatkozást kezd; ellenkező esetben a bővíthető sztring részeként értelmezendő. A változóhivatkozás tartalmazhat taghozzáférést vagy indexelést.

  • Az egyszerű változóhivatkozásokat (például $HOME) követő további karakterek is ugyanannak az argumentumnak a részei. A változó nevét kapcsos zárójelekbe ({}) csatolja, 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. $HOME.Length-more például két argumentumot eredményez: a $HOME.Length értékét és a sztringkonstans -moreértékét.

• Az idézőjelek (' és ") karakterláncokat kezdenek.

• Kapcsos zárójelek ({}) új szkriptblokkok létrehozása

• A vesszők (,) azokat a listákat vezetik be, amelyeket tömbökként adnak át, kivéve, ha a meghívott parancs egy natív alkalmazás. Ebben az esetben a vesszőket a bővíthető sztring részeként értelmezik. A kezdeti, egymást követő vagy záró vesszők nem támogatottak.

• A zárójelek (()) egy új kifejezést kezdenek.

• A subexpression operátor ($()) beágyazott kifejezést kezd

• A kezdeti @ jel (@) olyan kifejezésszintaxisokat kezd el, mint a splatting (@args), a tömbök (@(1,2,3)) és a hashtábla literálok (@{a=1;b=2}).

• (), $()és @() a token elején hozzanak 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.
  • Amikor egy idézőjelek nélküli literális $()-t követ, akkor bővíthető karakterláncként működik. A () egy új argumentumot kezd, amely egy kifejezés, míg a @()-t szó szerint veszik, és a @-ra. A () pedig egy új argumentumot indít el, amely szintén egy kifejezés.

• Minden mást bővíthető karakterláncként kezelünk, kivéve azokat a metakaraktereket, amelyeket ki kell kerülni. Lásd: Speciális karakterek kezelése.

  • Az argumentum mó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 fennmaradó argumentum értelmezését. További információkért lásd az alábbi elemző-törlési token szakaszt.

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 $a változó értéke 4.

példa	Üzemmód	Eredmény
2	Kifejezés	2 (egész szám)
`2	Kifejezés	"2" (parancs)
Write-Output 2	Kifejezés	2 (egész szám)
2+2	Kifejezés	4 (egész szám)
Write-Output 2+2	érvelés	2+2
Write-Output(2+2)	Kifejezés	4 (egész szám)
$a	Kifejezés	4 (egész szám)
Write-Output $a	Kifejezés	4 (egész szám)
$a+2	Kifejezés	6 (egész szám)
Write-Output $a+2	érvelés	"4+2" (sztring)
$-	érvelés	"$-" (parancs)
Write-Output $-	érvelés	"$-" (sztring)
a$a	Kifejezés	a$a (parancs)
Write-Output a$a	érvelés	"a4" (karaktersorozat)
a'$a'	Kifejezés	a$a (parancs)
Write-Output a'$a'	érvelés	a$a (sztring)
a"$a"	Kifejezés	a$a (parancs)
Write-Output a"$a"	érvelés	"a4" (karaktersorozat)
a$(2)	Kifejezés	"a$(2)" (parancs)
Write-Output a$(2)	érvelés	"A2" (karakterlánc)

Minden jogkivonat valamilyen objektumtípusként értelmezhető, például logikai vagy karakterlánc. 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	Üzemmód	Eredmény
Write-Output !1	argumentum	"!1" (sztring)
Write-Output (!1)	kifejezés	Hamis (logikai érték)
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 feloldására használható. Ez a leginkább hasznos az argumentum-üzemmódú metakarakterek kiszabadítására, amelyeket szó szerinti karakterként szeretne használni, nem pedig metakarakterként. 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 backtick karakter a sor végén is használható, így a következő sorban is folytatódhat a bevitel. 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éldául:

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 extra szóköz a backtick után megszakítja a sor 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 (+, -, -eqstb.) után
• Vessző (,) után egy tömbben
• Az olyan karakterek megnyitása után, mint [, {, (

Nagy paraméterkészlet esetén használjon inkább "splatting" technikát. Például:

$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

Az elemzést megállító 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.

Megjegyzé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 szintaxis elemzés leállításának tokenjével találkozik, a PowerShell a sor többi karakterét literáliské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. A sorfolytatási karakter (`) nem használható a hatás kiterjesztéséhez, és nem használhat parancselválasztót (;) a hatás megszakításához.

A %variable% környezeti változókra mutató hivatkozásokon kívül más dinamikus elemeket nem ágyazhat be a parancsba. A % karakterek %%-re való megadására nincs támogatás, úgy mint ahogyan a batch fájlokban megtehető. %<name>% tokenek mindig bővülnek. Ha <name> nem hivatkozik egy meghatározott környezeti változóra, akkor a token át lesz adva as-is-nak.

A stream átirányítása (például >file.txt) nem használható, mert azokat változatlan formában adják át a célparancsnak argumentumként.

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.exe, ami 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"

Megjegyzé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.

Figyelmeztetés

Az új viselkedés a Windows PowerShell 5.1-es 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 argumentum szükség szerinti átadását.

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 Standard.

Legacy a történelmi viselkedés. A Windows és a Standard mód működése ugyanaz, kivéve abban az esetben, ha Windows módban az alábbi fájlok meghívásai automatikusan a Legacy stílus szerinti argumentumátadást használják.

• 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 a $PSNativeCommandArgumentPassingLegacy vagy Standardértékre van állítva, az elemző nem ellenőrzi ezeket a fájlokat.

Megjegyzés:

Az alábbi példák a TestExe.exe eszközt használják. A forráskódból létrehozhat 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ó szó szerinti vagy bővíthető karakterláncok most már megőrződnek.

  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 láncok 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) egy natív parancsnak "C:\Program Files (x86)\Microsoft\" adja át, hogy idézőjeles sztringként kapja meg az elérési utat.

Windows vagy Standard módban a következő példák adják meg a várt eredményeket:

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

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

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

Megjegyzés:

A fordított perjel (\) karaktert a PowerShell nem ismeri fel escape karakterként. Ez a ProcessStartInfo.ArgumentListmö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óért lásd: Trace-Command.

Argumentumok továbbítása PowerShell-parancsoknak

A PowerShell 3.0-tól kezdve a paraméterek végi token (--) használatá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ét jelző token

A paraméterek végi jogkivonat (--) 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 használata vagy paraméterként való értelmezése nélkül is kiadhatja a -InputObject sztringet:

Write-Output -- -InputObject

-InputObject

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

Write-Output -- -InputObject $env:PROCESSOR_ARCHITECTURE

-InputObject
AMD64

Ez a viselkedés csak a PowerShell-parancsokra vonatkozik. Ha a -- tokent külső parancs meghívásakor használja, a -- sztring argumentumként adódik át a parancsnak.

TestExe -echoargs -a -b -- -c

A kimenet azt mutatja, hogy a -- argumentumként át van adva a TestExe-nek.

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étere a New-Item egy karakterláncot 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

• a_Parancs_Szintaxisról