tentang_Parsing

Deskripsi singkat

Menjelaskan cara PowerShell mengurai perintah.

Deskripsi panjang

Saat Anda memasukkan perintah di prompt perintah, PowerShell memecah teks perintah menjadi serangkaian segmen yang disebut token lalu menentukan cara menginterpretasikan setiap token.

Misalnya, jika Anda mengetik:

Write-Host book

PowerShell memecah perintah menjadi dua token, Write-Host dan book, dan menafsirkan setiap token secara independen menggunakan salah satu dari dua mode penguraian utama: mode ekspresi dan mode argumen.

Nota

Saat PowerShell menguraikan input perintah, PowerShell mencoba menyelesaikan nama perintah ke cmdlet atau executable asli. Jika nama perintah tidak memiliki kecocokan yang tepat, PowerShell akan menambahkan Get- ke perintah sebagai kata kerja default. Misalnya, PowerShell mengurai Service sebagai Get-Service. Tidak disarankan untuk menggunakan fitur ini karena alasan berikut:

  • Ini tidak efisien. Hal ini menyebabkan PowerShell mencari beberapa kali.
  • Program eksternal dengan nama yang sama diselesaikan terlebih dahulu, sehingga Anda mungkin tidak menjalankan cmdlet yang dimaksudkan.
  • Get-Help dan Get-Command tidak mengenali nama tanpa kata kerja.
  • Nama perintah mungkin merupakan kata cadangan atau kata kunci bahasa. Process adalah keduanya dan tidak dapat diselesaikan menjadi Get-Process.

Mode ekspresi

Mode ekspresi ditujukan untuk menggabungkan ekspresi, diperlukan untuk manipulasi nilai dalam bahasa skrip. Ekspresi adalah representasi nilai dalam sintaks PowerShell, dan bisa sederhana atau komposit, misalnya:

Ekspresi harfiah adalah representasi langsung dari nilai-nilainya:

'hello'
32

Ekspresi variabel membawa nilai variabel yang mereka referensikan:

$x
$Script:path

Operator menggabungkan ekspresi lain untuk evaluasi:

-12
-not $Quiet
3 + 7
$input.Length -gt 1
  • Literal string Karakter harus dimuat dalam tanda kutip.
  • Numbers diperlakukan sebagai nilai numerik daripada sebagai serangkaian karakter (kecuali lolos).
  • Operator, termasuk operator unary seperti - dan -not dan operator biner seperti + dan -gt, ditafsirkan sebagai operator dan menerapkan operasi masing-masing pada operandnya.
  • Atribut dan ekspresi konversi diurai sebagai ekspresi dan diterapkan ke ekspresi bawahan. Misalnya: [int] '7'.
  • Referensi variabel dievaluasi ke nilainya tetapi terlarang dan menyebabkan kesalahan pengurai.
  • Apa pun yang lain diperlakukan sebagai perintah untuk dijalankan.

Mode argumen

Saat mengurai, PowerShell pertama-tama terlihat menginterpretasikan input sebagai ekspresi. Tetapi ketika pemanggilan perintah ditemui, penguraian berlanjut dalam mode argumen. Jika Anda memiliki argumen yang berisi spasi, seperti jalur, maka Anda harus mengapit nilai argumen tersebut dalam tanda kutip.

Mode argumen dirancang untuk mengurai argumen dan parameter untuk perintah di lingkungan shell. Semua input diperlakukan sebagai string yang dapat diperluas kecuali menggunakan salah satu sintaks berikut:

  • Tanda dolar ($) diikuti dengan nama variabel memulai referensi variabel, jika tidak, itu ditafsirkan sebagai bagian dari string yang dapat diperluas. Referensi variabel dapat mencakup akses anggota atau pengindeksan.

    • Karakter tambahan yang mengikuti referensi variabel sederhana, seperti $HOME, dianggap sebagai bagian dari argumen yang sama. Sertakan nama variabel dalam kurung kurawal ({}) untuk memisahkannya dari karakter berikutnya. Misalnya, ${HOME}.
    • Saat referensi variabel menyertakan akses anggota, karakter tambahan pertama dianggap sebagai awal argumen baru. Misalnya $HOME.Length-more menghasilkan dua argumen: nilai $HOME.Length dan string harfiah -more.

  • Tanda kutip (' dan ") memulai string

  • Kurung kurawal ({}) memulai blokir skrip baru

  • Koma (,) digunakan untuk memperkenalkan daftar yang diteruskan sebagai array, kecuali jika perintah yang dipanggil adalah aplikasi native, dalam hal ini, diartikan sebagai bagian dari string yang dapat mengembang. Koma awal, berturut-turut, atau yang di akhir tidak didukung.

  • Tanda kurung (()) memulai ekspresi baru

  • Operator subekspresi ($()) memulai ekspresi yang disematkan

  • Simbol 'at' awal (@) memulai sintaks ekspresi seperti splatting (@args), array (@(1,2,3)), dan literal tabel hash (@{a=1;b=2}).

  • (), $(), dan @() di awal token membuat konteks penguraian baru yang dapat berisi ekspresi atau perintah berlapis.

    • Ketika diikuti oleh karakter tambahan, karakter tambahan pertama dianggap sebagai awal argumen baru yang terpisah.
    • Ketika didahului oleh $() harfiah yang tidak dikutip berfungsi seperti string yang dapat diperluas, () memulai argumen baru yang merupakan ekspresi, dan @() diambil sebagai @ harfiah dengan () memulai argumen baru yang merupakan ekspresi.

  • Segala sesuatu yang lain diperlakukan sebagai string yang dapat diperluas, kecuali metakarakter yang masih perlu melarikan diri. Lihat Menangani karakter khusus.

    • Metakarakter-mode argumen (karakter dengan arti sintaktik khusus) adalah: <space> ' " ` , ; ( ) { } | & < > @ #. Dari jumlah ini, < > @ # hanya khusus pada awal token.

  • Token stop-parsing (--%) mengubah interpretasi semua argumen yang tersisa. Untuk informasi selengkapnya, lihat bagian stop-parsing token di bawah ini.

Contoh

Tabel berikut ini menyediakan beberapa contoh token yang diproses dalam mode ekspresi dan mode argumen dan evaluasi token tersebut. Untuk contoh-contoh ini, nilai variabel $a adalah 4.

Contoh Modus Hasil
2 Ekspresi 2 (bilangan bulat)
`2 Ekspresi "2" (perintah)
Write-Output 2 Ekspresi 2 (bilangan bulat)
2+2 Ekspresi 4 (bilangan bulat)
Write-Output 2+2 Argumen "2+2" (string)
Write-Output(2+2) Ekspresi 4 (bilangan bulat)
$a Ekspresi 4 (bilangan bulat)
Write-Output $a Ekspresi 4 (bilangan bulat)
$a+2 Ekspresi 6 (bilangan bulat)
Write-Output $a+2 Argumen "4+2" (string)
$- Argumen "$-" (perintah)
Write-Output $- Argumen "$-" (string)
a$a Ekspresi a$a (perintah)
Write-Output a$a Argumen "a4" (string)
a'$a' Ekspresi a$a (perintah)
Write-Output a'$a' Argumen a$a (string)
a"$a" Ekspresi a$a (perintah)
Write-Output a"$a" Argumen "a4" (string)
a$(2) Ekspresi "a$(2)" (perintah)
Write-Output a$(2) Argumen "a2" (string)

Setiap token dapat ditafsirkan sebagai semacam jenis objek, seperti Boolean atau string . PowerShell mencoba menentukan jenis objek dari ekspresi. Jenis objek tergantung pada jenis parameter yang diharapkan perintah dan pada apakah PowerShell tahu cara mengonversi argumen ke jenis yang benar. Tabel berikut ini memperlihatkan beberapa contoh jenis yang dihubungkan dengan nilai yang dikembalikan oleh ekspresi.

Contoh Modus Hasil
Write-Output !1 argumen "!1" (string)
Write-Output (!1) ekspresi False (Boolean)
Write-Output (2) ekspresi 2 (bilangan bulat)
Set-Variable AB A,B argumen 'A','B' (larik)
CMD /CECHO A,B argumen A,B (string)
CMD /CECHO $AB ekspresi 'A B' (array)
CMD /CECHO :$AB argumen ':A B' (string)

Menangani karakter khusus

Karakter "backtick" (`) dapat digunakan untuk menghindari interpretasi karakter khusus apa pun dalam sebuah ekspresi. Ini paling berguna untuk menghindari penggunaan metakarakter mode argumen yang ingin Anda gunakan sebagai karakter literal daripada sebagai metakarakter. Misalnya, untuk menggunakan tanda dolar ($) sebagai harfiah dalam string yang dapat diperluas:

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

The value of $ErrorActionPreference is 'Continue'.

Kelanjutan baris

Karakter backtick juga dapat digunakan di akhir baris untuk memungkinkan Anda melanjutkan input pada baris berikutnya. Ini meningkatkan keterbacaan perintah yang mengambil beberapa parameter dengan nama panjang dan nilai argumen. Misalnya:

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

Namun, Anda harus menghindari penggunaan kelanjutan baris.

  • Karakter backtick bisa sulit dilihat dan mudah dilupakan.
  • Ruang ekstra setelah backtick memutus kelanjutan baris. Karena ruang sulit untuk melihat mungkin sulit untuk menemukan kesalahan.

PowerShell menyediakan beberapa cara untuk memecah baris pada titik-titik alami dalam sintaks.

  • Setelah karakter pipa (|)
  • Setelah operator biner (+, -, -eq, dll.)
  • Setelah tanda koma (,) dalam array
  • Setelah membuka karakter seperti [, {, (

Untuk kumpulan parameter yang besar, gunakan 'splatting' sebagai gantinya. Misalnya:

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

Meneruskan argumen ke perintah asli

Saat menjalankan perintah asli dari PowerShell, argumen pertama kali diurai oleh PowerShell. Argumen yang diurai kemudian digabungkan ke dalam satu string dengan setiap parameter yang dipisahkan oleh spasi.

Misalnya, perintah berikut memanggil program icacls.exe.

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

Untuk menjalankan perintah ini di PowerShell 2.0, Anda harus menggunakan karakter escape untuk mencegah PowerShell salah menafsirkan tanda kurung.

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

Token penghenti-pemrosesan

Dimulai di PowerShell 3.0, Anda dapat menggunakan token stop-parsing () untuk menghentikan PowerShell menginterpretasikan input sebagai perintah atau ekspresi PowerShell.

Nota

Token stop-parsing hanya ditujukan untuk menggunakan perintah asli pada platform Windows.

Saat memanggil perintah asli, letakkan token stop-parsing sebelum argumen program. Teknik ini jauh lebih mudah daripada menggunakan karakter escape untuk mencegah misinterpretasi.

Ketika menemukan token stop-parsing, PowerShell memperlakukan karakter yang tersisa di baris sebagai harfiah. Satu-satunya interpretasi yang dilakukannya adalah mengganti nilai untuk variabel lingkungan yang menggunakan notasi Windows standar, seperti %USERPROFILE%.

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

PowerShell mengirimkan string perintah berikut ke program icacls.exe:

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

Token stop-parsing hanya efektif hingga karakter baris baru atau alur berikutnya. Anda tidak dapat menggunakan karakter kelanjutan baris (`) untuk memperluas efeknya atau menggunakan pemisah perintah (;) untuk mengakhiri efeknya.

Selain %variable% referensi variabel lingkungan, Anda tidak dapat menyematkan elemen dinamis lainnya dalam perintah. Mengganti karakter % menjadi %%, seperti yang dapat dilakukan dalam file batch, tidak didukung. %<name>% token terus diperluas. Jika <name> tidak merujuk ke variabel lingkungan yang ditentukan, token diteruskan melalui as-is.

Anda tidak dapat menggunakan pengalihan aliran (seperti >file.txt) karena diteruskan secara literal sebagai argumen untuk perintah target.

Dalam contoh berikut, langkah pertama menjalankan perintah tanpa menggunakan token stop-parsing. PowerShell mengevaluasi string yang dikutip dan meneruskan nilai (tanpa tanda kutip) ke cmd.exe, yang menghasilkan kesalahan.

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"

Nota

Token stop-parsing tidak diperlukan saat menggunakan cmdlet PowerShell. Namun, mungkin berguna untuk meneruskan argumen ke fungsi PowerShell yang dirancang untuk memanggil perintah asli dengan argumen tersebut.

Meneruskan argumen yang berisi karakter kutipan

Beberapa perintah asli mengharapkan argumen yang berisi tanda kutip. PowerShell 7.3 mengubah cara baris perintah diurai untuk perintah asli.

Perhatian

Perilaku baru adalah perubahan melanggar dari perilaku Windows PowerShell 5.1. Ini dapat merusak skrip dan otomatisasi yang mengatasi berbagai masalah saat memanggil aplikasi asli. Gunakan token stop-parsing (--%) atau cmdlet Start-Process untuk menghindari penerusan argumen asli jika diperlukan.

Variabel preferensi $PSNativeCommandArgumentPassing baru mengontrol perilaku ini. Variabel ini memungkinkan Anda untuk memilih perilaku saat runtime. Nilai yang valid adalah Legacy, Standard, dan Windows. Perilaku default tergantung pada platform. Pada platform Windows, pengaturan defaultnya adalah Windows, dan pada platform non-Windows, pengaturan defaultnya adalah Standard.

Legacy adalah perilaku yang sudah ada sejak lama. Perilaku mode Windows dan Standard adalah sama, kecuali, dalam mode Windows, pemanggilan terhadap file-file berikut secara otomatis menggunakan pengoperan argumen gaya Legacy.

  • cmd.exe
  • cscript.exe
  • wscript.exe
  • diakhir dengan .bat
  • diakhir dengan .cmd
  • diakhir dengan .js
  • diakhir dengan .vbs
  • diakhir dengan .wsf

Jika $PSNativeCommandArgumentPassing diatur ke Legacy atau Standard, pengurai tidak memeriksa file-file ini.

Nota

Contoh berikut menggunakan alat TestExe.exe. Anda dapat membangun TestExe dari kode sumber. Lihat TestExe di repositori sumber PowerShell.

Perilaku baru yang disediakan oleh perubahan ini:

  • String literal atau yang dapat diperluas dengan tanda kutip yang disematkan, dan tanda kutip tersebut sekarang dipertahankan.

    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>

  • String kosong sebagai argumen sekarang dipertahankan:

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

Tujuan dari contoh-contoh ini adalah untuk meneruskan jalur direktori (dengan spasi dan tanda kutip) "C:\Program Files (x86)\Microsoft\" ke perintah asli sehingga menerima jalur sebagai string yang dikutip.

Dalam mode Windows atau Standard, contoh berikut menghasilkan hasil yang diharapkan:

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

Untuk mendapatkan hasil yang sama dalam mode Legacy, Anda harus menghindari tanda kutip atau menggunakan token stop-parsing (--%):

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

Nota

Karakter garis miring terbalik (\) tidak dikenali sebagai karakter pelolos oleh PowerShell. Ini adalah karakter escape yang digunakan oleh API yang mendasari untuk ProcessStartInfo.ArgumentList.

PowerShell 7.3 juga menambahkan kemampuan untuk melacak pengikatan parameter untuk perintah asli. Untuk informasi selengkapnya, lihat Trace-Command.

Meneruskan argumen ke perintah PowerShell

Mulai dari PowerShell 3.0, Anda dapat menggunakan token akhir-dari-parameter (--) untuk menghentikan PowerShell menginterpretasikan input sebagai parameter PowerShell. Ini adalah konvensi yang ditentukan dalam spesifikasi POSIX Shell dan Utilitas.

Token akhir parameter

Token akhir parameter (--) menunjukkan bahwa semua argumen yang mengikutinya akan diteruskan dalam bentuk sebenarnya seolah-olah tanda kutip ganda ditempatkan di sekitarnya. Misalnya, menggunakan -- Anda dapat menghasilkan string -InputObject tanpa menggunakan tanda kutip atau membuatnya ditafsirkan sebagai parameter:

Write-Output -- -InputObject

-InputObject

Tidak seperti token stop-parsing (--%), nilai apa pun yang mengikuti token -- dapat ditafsirkan sebagai ekspresi oleh PowerShell.

Write-Output -- -InputObject $Env:PROCESSOR_ARCHITECTURE

-InputObject
AMD64

Perilaku ini hanya berlaku untuk perintah PowerShell. Jika Anda menggunakan token -- saat memanggil perintah eksternal, string -- diteruskan sebagai argumen ke perintah tersebut.

TestExe -echoargs -a -b -- -c

Output menunjukkan bahwa -- diteruskan sebagai argumen ke TestExe.

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

Tilde (~)

Karakter tilde (~) memiliki arti khusus dalam PowerShell. Saat digunakan dengan perintah PowerShell di awal jalur, PowerShell memperluas karakter tilde ke direktori beranda pengguna. Jika Anda menggunakan karakter tilde di tempat lain di jalur, karakter tersebut diperlakukan sebagai karakter harfiah.

PS D:\temp> $PWD

Path
----
D:\temp

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

Path
----
C:\Users\user2

Dalam contoh ini, parameter Nama dari New-Item mengharapkan string. Karakter tilde diperlakukan sebagai karakter harfiah. Untuk berpindah ke direktori yang baru dibuat, Anda harus menandai jalurnya dengan karakter tilde.

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 menambahkan fitur eksperimental untuk memperluas tilde ke direktori beranda pengguna untuk perintah asli. Untuk informasi selengkapnya, lihat fitur PSNativeWindowsTildeExpansion pada Menggunakan Fitur Eksperimental di PowerShell.

String yang diperluas diteruskan ke perintah asli. Dengan memperluas tilde, PowerShell mencegah kesalahan untuk perintah asli pada Windows yang tidak mendukung karakter tilde. Anda dapat melihat string yang dihasilkan dengan melacak pengikatan parameter menggunakan Trace-Command.

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

Perhatikan bahwa ~\repocache.clixml diperluas ke C:\Users\user2\repocache.clixml.

Lihat juga

  • Last updated on