Ayrıştırma Hakkında

Kısa açıklama

PowerShell'in komutları nasıl ayrıştırdığı açıklanır.

Uzun açıklama

Komut istemine bir komut girdiğinizde PowerShell, komut metnini belirteçleri adlı bir kesim dizisine böler ve sonra her belirtecin nasıl yorumleneceğini belirler.

Örneğin, şunu yazarsanız:

Write-Host book

PowerShell, komutu Write-Host ve bookiki belirteçte keser ve iki ana ayrıştırma modundan birini kullanarak her belirteci bağımsız olarak yorumlar: ifade modu ve bağımsız değişken modu.

Not

PowerShell komut girişini ayrıştırdıkça komut adlarını cmdlet'lere veya yerel yürütülebilir dosyalara çözümlemeye çalışır. Bir komut adının tam eşleşmesi yoksa, PowerShell, varsayılan fiil olarak Get-'ı komutun önüne ön ek olarak ekler. Örneğin, PowerShell ServiceGet-Serviceolarak ayrıştırıyor. Bu özelliğin aşağıdaki nedenlerle kullanılması önerilmez:

Bu verimsiz. Bu, PowerShell'in birden çok kez aramasına neden olur.
Önce aynı ada sahip dış programlar çözümlenir, bu nedenle istenen cmdlet'i yürütemeyebilirsiniz.
Get-Help ve Get-Command fiilsiz adları tanımaz.
Komut adı ayrılmış bir sözcük veya dil anahtar sözcüğü olabilir. Process her ikisidir ve Get-Process'e çözümlenemez.

İfade modu

İfade modu, bir betik dilinde değer işleme için gerekli olan ifadeleri birleştirmeye yöneliktir. İfadeler PowerShell söz dizimindeki değerlerin temsilleridir ve basit veya bileşik olabilir, örneğin:

Literal ifadeler, değerlerinin doğrudan temsilleridir.

'hello'
32

Değişken ifadeleri başvurdıkları değişkenin değerini taşır:

$x
$Script:path

İşleçler değerlendirme için diğer ifadeleri birleştirir:

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

Karakter dizeleri tırnak işareti içinde olmalıdır.
Sayılar bir dizi karakter olarak değil, sayısal değerler olarak değerlendirilir (özellikle belirtilmedikçe).
İşleçleri, - ve -not gibi tekli işleçler ile + ve -gtgibi ikili işleçler de dahil olmak üzere işleçler işleç olarak yorumlanır ve ilgili işlemlerini bağımsız değişkenlerine (işlenenler) uygular.
Öznitelik ve dönüştürme ifadeleri ifadeler olarak ayrıştırılır ve alt ifadelere uygulanır. Örneğin: [int] '7'.
Değişken başvuruları değerlerine göre değerlendirilir ancak sıçraması yasaktır ve ayrıştırıcı hatasına neden olur.
Diğer her şey çağrılacak bir komut olarak değerlendirilir.

Bağımsız değişken modu

Ayrıştırma sırasında PowerShell ilk olarak girişi bir ifade olarak yorumlamaya bakar. Bir komut çağrısı ile karşılaşıldığında, ayrıştırma, argüman modunda devam eder. Yollar gibi boşluklar içeren bağımsız değişkenleriniz varsa, bu bağımsız değişken değerlerini tırnak içine almanız gerekir.

Bağımsız değişken modu, bir kabuk ortamındaki komutlar için bağımsız değişkenleri ve parametreleri analiz etmek üzere tasarlanmıştır. Tüm girişler, aşağıdaki söz dizimlerinden birini kullanmadığı sürece genişletilebilir bir dize olarak değerlendirilir:

Dolar işareti ($) ve ardından değişken adı bir değişken başvurusu başlatır, aksi takdirde genişletilebilir dizenin bir parçası olarak yorumlanır. Değişken referansı üye erişimi veya indeksleme içerebilir.
- Basit değişken referanslarının, örneğin $HOMEgibi, ardında gelen ek karakterler aynı bağımsız değişkenin parçası olarak kabul edilir. Değişken adını sonraki karakterlerden ayırmak için ayraç ({}) içine alın. Örneğin, ${HOME}.
- Değişken başvurusu üye erişimi içerdiğinde, ek karakterlerin ilki yeni bir bağımsız değişkenin başlangıcı olarak kabul edilir. Örneğin, $HOME.Length-more iki bağımsız değişkenle sonuçlanır: $HOME.Length değeri ve dize sabiti -more.
Tırnak işaretleri (' ve ") dizeleri başlatır
Ayraçlar ({}) yeni bir betik bloğu başlatır
Virgüller (,), çağrılan komut yerel bir uygulama olmadığı sürece dizi olarak geçirilen listeleri tanıtır; bu durumda bunlar genişletilebilir dizenin bir parçası olarak yorumlanır. İlk, ardışık veya sondaki virgüller desteklenmez.
Parantezler (()) yeni bir ifade başlatır
Alt ifade işleci ($()) eklenmiş ifadeyi başlatır
Başlangıçtaki '@' işareti (@), splatting (@args), diziler (@(1,2,3)) ve karma tablo sabitleri (@{a=1;b=2}) gibi ifade söz dizimlerini başlatır.
belirtecin başında (), $()ve @(), ifadeler veya iç içe komutlar içerebilen yeni bir ayrıştırma bağlamı oluşturur.
- Ek karakterler eklendiğinde, ilk eklenen karakter yeni, ayrı bir bağımsız değişkenin başlangıcı olarak kabul edilir.
- Tırnak kullanılmayan değişmez değer öncesinde, $() genişletilebilir bir dize gibi çalışır, () ifade olan yeni bir bağımsız değişken başlatır ve @(), @ adlı değişmez değer olarak alınır; onunla birlikte (), ifade olan yeni bir bağımsız değişken başlatır.
Diğer her şey, hala kaçış gerektiren meta karakterler hariç, genişletilebilir bir dize olarak ele alınır. bkz. özel karakterleri işleme.
- Bağımsız değişken modu metakarakterleri (özel sözdizimsel anlamı olan karakterler) şöyledir: <space> ' " ` , ; ( ) { } | & < > @ #. Bunlardan < > @ # yalnızca belirtecin başında özeldir.
Ayrıştırmayı durdurma belirteci (--%), kalan tüm bağımsız değişkenlerin yorumlanmasını değiştirir. Daha fazla bilgi için aşağıdaki stop-parsing token bölümüne bakın.

Örnekler

Aşağıdaki tabloda, ifade modunda ve bağımsız değişken modunda işlenen belirteçlerin birkaç örneği ve bu belirteçlerin değerlendirilmesi sağlanır. Bu örnekler için $a değişkeninin değeri 4.

Örnek	Mod / Ayar / Durum	Sonuç
`2`	İfade	2 (tamsayı)
`2	İfade	"2" (komut)
`Write-Output 2`	İfade	2 (tamsayı)
`2+2`	İfade	4 (tamsayı)
`Write-Output 2+2`	Tartışma	"2+2" (dize)
`Write-Output(2+2)`	İfade	4 (tamsayı)
`$a`	İfade	4 (tamsayı)
`Write-Output $a`	İfade	4 (tamsayı)
`$a+2`	İfade	6 (tamsayı)
`Write-Output $a+2`	Tartışma	"4+2" (dize)
`$-`	Tartışma	"$-" (komut)
`Write-Output $-`	Tartışma	"$-" (dize)
`a$a`	İfade	a$a (komut)
`Write-Output a$a`	Tartışma	"a4" (dize)
`a'$a'`	İfade	a$a (komut)
`Write-Output a'$a'`	Tartışma	a$a (dize)
`a"$a"`	İfade	a$a (komut)
`Write-Output a"$a"`	Tartışma	"a4" (dize)
`a$(2)`	İfade	"a$(2)" (komut)
`Write-Output a$(2)`	Tartışma	"a2" (dize)

Her belirteç Boole veya Stringgibi bir tür nesne türü olarak yorumlanabilir. PowerShell, ifadeden nesne türünü belirlemeye çalışır. Nesne türü, bir komutun beklediği parametrenin türüne ve PowerShell'in bağımsız değişkeni doğru türe nasıl dönüştüreceklerini bilip bilmediğine bağlıdır. Aşağıdaki tabloda, ifadeler tarafından döndürülen değerlere atanan türlerin çeşitli örnekleri gösterilmektedir.

Örnek	Mod / Ayar / Durum	Sonuç
`Write-Output !1`	tartışma	"!1" (dize)
`Write-Output (!1)`	ifade	Yanlış (Boolean)
`Write-Output (2)`	ifade	2 (tamsayı)
`Set-Variable AB A,B`	tartışma	'A','B' (dizi)
`CMD /CECHO A,B`	tartışma	'A,B' (dize)
`CMD /CECHO $AB`	ifade	'A B' (dizi)
`CMD /CECHO :$AB`	tartışma	':A B' (dize)

Özel karakterleri işleme

Backtick karakteri (`) bir ifadedeki herhangi bir özel karakterden kaçmak için kullanılabilir. Bu, en çok meta karakter yerine sabit karakter olarak kullanmak istediğiniz bağımsız değişken modu meta karakterlerinden kaçmak için kullanışlıdır. Örneğin, genişletilebilir bir dizede sabit değer olarak dolar işaretini ($) kullanmak için:

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

The value of $ErrorActionPreference is 'Continue'.

Satır devamlılığı

Ters tırnak işareti (`), girişi bir sonraki satıra taşımak için satırın sonunda da kullanılabilir. Bu, uzun adlara ve bağımsız değişken değerlerine sahip birkaç parametre alan bir komutun okunabilirliğini artırır. Örneğin:

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

Ancak, satır devamlılığı kullanmaktan kaçınmanız gerekir.

Backtick karakterlerini görmek zor olabilir ve kolayca unutabilirsiniz.
Ters tırnak sonrasındaki fazladan bir boşluk satır devamını bozar. Alanı görmek zor olduğundan hatayı bulmak zor olabilir.

PowerShell, söz diziminde doğal noktalarda çizgileri kesmenin çeşitli yollarını sağlar.

Dikey çizgi karakterleri sonrası (|)
İkili işleçlerin ardından (+, -, -eqvb.)
Dizide virgülden sonra (,)
[, {, ( gibi karakterlerin açılmasından sonra

Büyük parametre kümesi için bunun yerine "splatting" yöntemini kullanın. Örneğin:

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

Bağımsız değişkenleri yerel komutlara geçirme

PowerShell'den yerel komutlar çalıştırılırken, bağımsız değişkenler önce PowerShell tarafından ayrıştırılır. Ayrıştırılan bağımsız değişkenler daha sonra her parametre bir boşlukla ayrılmış olarak tek bir dizede birleştirilir.

Örneğin, aşağıdaki komut icacls.exe programını çağırır.

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

Bu komutu PowerShell 2.0'da çalıştırmak için, PowerShell'in parantezleri yanlış yorumlamasını önlemek için kaçış karakterlerini kullanmanız gerekir.

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

Ayrıştırmayı durdurma belirteci

PowerShell 3.0 ile başlayarak, (--%) belirtecini kullanarak PowerShell'in girdileri komutlar veya ifadeler olarak yorumlamasını engelleyebilirsiniz.

Not

Ayrıştırma durdurma belirteci yalnızca Windows platformlarında yerel komutları kullanmak için tasarlanmıştır.

Yerel bir komut çağırırken, ayrıştırmayı durduran belirteci program bağımsız değişkenlerinden önce yerleştirin. Bu teknik, yanlış yorumlamayı önlemek için kaçış karakterleri kullanmaktan çok daha kolaydır.

Durdurma işaretleme belirteci ile karşılaştığında, PowerShell, satırdaki kalan karakterleri olduğu gibi ele alır. Yaptığı tek yorum, %USERPROFILE%gibi standart Windows gösterimini kullanan ortam değişkenleri için değerleri değiştirmektir.

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

PowerShell, icacls.exe programına aşağıdaki komut dizesini gönderir:

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

Ayrıştırmayı durdurma belirteci yalnızca sonraki yeni satıra veya boru hattı karakterine kadar geçerlidir. Efektini genişletmek için satır devamlılığı karakterini (`) veya etkisini sonlandırmak için bir komut sınırlayıcısı (;) kullanamazsınız.

%variable% ortam değişkeni başvuruları dışında, komutuna başka dinamik öğe ekleyemezsiniz. %olarak bir %% karakterinden kaçış, toplu iş dosyalarının içinde yapabileceğiniz şekilde desteklenmez. %<name>% belirteçleri sabit bir şekilde genişletilir. <name> tanımlı bir ortam değişkenine başvurmazsa belirteç as-isüzerinden geçirilir.

Akış yönlendirmesini (örneğin >file.txtgibi) kullanamazsınız çünkü bunlar hedef komuta bağımsız değişken olarak doğrudan iletilir.

Aşağıdaki örnekte, ilk adım stop-parsing belirtecini kullanmadan bir komut çalıştırır. PowerShell, tırnak içindeki dizeyi değerlendirir ve değerini (tırnak işaretleri olmadan) cmd.exe'a gönderir, bu da bir hatayla sonuçlanır.

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"

Not

PowerShell cmdlet'leri kullanılırken ayrıştırmayı durdurma belirteci gerekli değildir. Ancak, bağımsız değişkenleri yerel bir komutu bu bağımsız değişkenlerle çağırmak üzere tasarlanmış bir PowerShell işlevine geçirmek faydalı olabilir.

Tırnak karakterleri içeren argümanları geçirme

Bazı yerel komutlar, tırnak işaretleri içeren bağımsız değişkenler bekler. PowerShell 7.3, komut satırının yerel komutlar için ayrıştırma şeklini değiştirdi.

Dikkat

Yeni davranış, Windows PowerShell 5.1 davranışına göre uyumluluğu bozan bir değişiklik olarak tanımlanır. Bu, yerel uygulamaları çağırma sırasında karşılaşılan çeşitli sorunlara geçici çözüm getiren betikleri ve otomasyonu bozabilir. Gerektiğinde yerel bağımsız değişken geçişini önlemek için durdurma ayrıştırma belirtecini (--%) veya Start-Process cmdlet'ini kullanın.

Yeni $PSNativeCommandArgumentPassing tercih değişkeni bu davranışı denetler. Bu değişken çalışma zamanında davranışı seçmenize olanak tanır. Geçerli değerler Legacy, Standardve Windows. Varsayılan davranış platforma özgüdür. Windows platformlarında varsayılan ayar Windows ve Windows dışı platformlar varsayılan olarak Standardolarak ayarlanır.

Legacy tarihi davranıştır. Windows ve Standard modları, davranış açısından aynıdır; ancak, Windows modunda, aşağıdaki dosyaların çağrıldığında, otomatik olarak Legacy tarzı bağımsız değişken geçirimi kullanılır.

cmd.exe
cscript.exe
wscript.exe
.bat ile biten
.cmd ile biten
.js ile biten
.vbs ile biten
.wsf ile biten

$PSNativeCommandArgumentPassing Legacy veya Standardolarak ayarlanırsa, ayrıştırıcı bu dosyaları denetlemez.

Not

Aşağıdaki örneklerde TestExe.exe aracı kullanılır. Kaynak koddan TestExe oluşturabilirsiniz. Bkz. PowerShell kaynak deposunda TestExe.

Bu değişiklikle kullanıma sunulan yeni davranışlar:

Tırnak işaretleri eklenmiş sabit veya genişletilebilir dizeler artık korunur:

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>

Bağımsız değişken olarak boş dizeler artık korunuyor:

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

Bu örneklerin amacı, dizin yolunu (boşluklar ve tırnak işaretleri ile) yerel bir komutla "C:\Program Files (x86)\Microsoft\" geçirerek yolu tırnak içinde bir dize olarak almaktır.

Windows veya Standard modunda aşağıdaki örnekler beklenen sonuçları üretir:

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

aynı sonuçları Legacy modunda almak için tırnak işaretlerini kaçırmanız veya ayrıştırmayı durdurma belirtecini (--%) kullanmanız gerekir:

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

Not

Ters eğik çizgi (\) karakteri, PowerShell tarafından kaçış karakteri olarak tanınmaz. ProcessStartInfo.ArgumentListiçin temel API tarafından kullanılan kaçış karakteridir.

PowerShell 7.3 ayrıca yerel komutlar için parametre bağlamasını izleme özelliğini de ekledi. Daha fazla bilgi için bkz. Trace-Command.

Bağımsız değişkenleri PowerShell komutlarına geçirme

PowerShell 3.0'dan başlayarak, PowerShell'in girişi PowerShell parametresi olarak yorumlamasını durdurmak için parametre sonu belirtecini (--) kullanabilirsiniz. Bu, POSIX Kabuğu ve Yardımcı Programlar spesifikasyonunda belirtilen bir konvansiyondur.

Parametre bitiş belirteci

Parametre sonu belirteci (--), bunu izleyen tüm bağımsız değişkenlerin, çevrelerine çift tırnak işareti yerleştirilmiş gibi orijinal halleriyle geçirileceğini belirtir. Örneğin, -- kullanarak, tırnak işaretleri kullanmadan veya bir parametre olarak yorumlanmadan, -InputObject dizisini çıktı verebilirsiniz.

Write-Output -- -InputObject

-InputObject

Stop-ayrıştırma (--%) belirtecinin aksine, -- belirtecini izleyen tüm değerler PowerShell tarafından ifade olarak yorumlanabilir.

Write-Output -- -InputObject $Env:PROCESSOR_ARCHITECTURE

-InputObject
AMD64

Bu davranış yalnızca PowerShell komutları için geçerlidir. Dış komutu çağırırken -- belirtecini kullanırsanız, -- ifadesi bu komuta argüman olarak geçirilir.

TestExe -echoargs -a -b -- -c

Çıktı, --'ın TestExe'e bir bağımsız değişken olarak geçirildiğini gösterir.

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

Tilde (~)

tilde karakterinin (~) PowerShell'de özel bir anlamı vardır. PowerShell, bir yolun başında PowerShell komutları ile kullanıldığında, tilde karakterini kullanıcının ana dizinine genişletir. Tilde karakterini bir yolun başka herhangi bir yerinde kullanırsanız, sabit karakter olarak değerlendirilir.

PS D:\temp> $PWD

Path
----
D:\temp

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

Path
----
C:\Users\user2

Bu örnekte, New-Item parametresi bir dize bekler. tilde karakteri sabit karakter olarak değerlendirilir. Yeni oluşturulan dizine geçmek için yolu tilde karakteriyle belirtmeniz gerekir.

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

PowerShell 7.5-preview.2, yerel komutlar için tilde'yi kullanıcının giriş dizinine genişletmek için deneysel bir özellik ekler. Daha fazla bilgi içinPowerShell'de Deneysel Özellikleri Kullanma'daki bölümünde yer alan özelliğine bakın.

Genişletilmiş dize yerel komuta aktarılır. PowerShell tilde'yi genişleterek Windows'ta tilde karakterini desteklemeyen yerel komutlar için hata oluşmasını önler. elde edilen dizeyi, Trace-Commandkullanarak parametre bağlamasını izleyerek görebilirsiniz.

Trace-Command -Name ParameterBinding -Expression {
    findstr /C:\foo" ~\repocache.clixml
} -PSHost

DEBUG: 2024-05-06 15:13:46.8268 ParameterBinding Information: 0 : BIND NAMED native application line args [C:\Windows\system32\findstr.exe]
DEBUG: 2024-05-06 15:13:46.8270 ParameterBinding Information: 0 :     BIND cmd line arg [/C:\oo] to position [0]
DEBUG: 2024-05-06 15:13:46.8271 ParameterBinding Information: 0 :     BIND cmd line arg [C:\Users\user2\repocache.clixml] to position [1]
DEBUG: 2024-05-06 15:13:46.8322 ParameterBinding Information: 0 : CALLING BeginProcessing

~\repocache.clixml C:\Users\user2\repocache.clixmlolarak genişletildiğine dikkat edin.

Ayrıca bakınız

about_Command_Syntax

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Last updated on 2026-01-18