about_Debuggers
Deskripsi singkat
Menjelaskan debugger PowerShell.
Deskripsi panjang
Penelusuran kesalahan adalah proses memeriksa skrip saat sedang berjalan untuk mengidentifikasi dan memperbaiki kesalahan dalam instruksi skrip. Debugger PowerShell dapat membantu Anda memeriksa dan mengidentifikasi kesalahan dan inefisiensi dalam skrip, fungsi, perintah, konfigurasi PowerShell Desired State Configuration (DSC), atau ekspresi Anda.
Dimulai di PowerShell 5.0, debugger PowerShell telah diperbarui untuk men-debug skrip, fungsi, perintah, konfigurasi, atau ekspresi yang berjalan di konsol atau Windows PowerShell Integrated Scripting Environment (ISE) di komputer jarak jauh.
Catatan
WINDOWS PowerShell ISE hanya mendukung Windows PowerShell. Untuk PowerShell 6 dan yang lebih tinggi, Anda harus menggunakan Visual Studio Code dengan ekstensi untuk PowerShell. Untuk informasi selengkapnya, lihat Penelusuran kesalahan dengan Visual Studio Code.
Cmdlet Debugger
Debugger PowerShell menyertakan set cmdlet berikut:
Set-PSBreakpoint: Mengatur titik henti pada baris, variabel, dan perintah.Get-PSBreakpoint: Mendapatkan titik henti dalam sesi saat ini.Disable-PSBreakpoint: Menonaktifkan titik henti dalam sesi saat ini.Enable-PSBreakpoint: Mengaktifkan kembali titik henti dalam sesi saat ini.Remove-PSBreakpoint: Menghapus titik henti dari sesi saat ini.Get-PSCallStack: Menampilkan tumpukan panggilan saat ini.
Memulai dan menghentikan debugger
Untuk memulai debugger, atur satu atau beberapa titik henti lalu jalankan skrip, perintah, atau fungsi yang ingin Anda debug.
Saat Anda mencapai titik henti, eksekusi berhenti, dan kontrol diserahkan ke debugger.
Untuk menghentikan debugger, jalankan skrip, perintah, atau fungsi hingga selesai.
Atau, ketik stop atau t.
Perintah debugger
Saat Anda menggunakan debugger di konsol PowerShell, gunakan perintah berikut untuk mengontrol eksekusi. Di Windows PowerShell ISE, gunakan perintah pada menu Debug.
Catatan
Untuk informasi tentang cara menggunakan debugger di aplikasi host lain, lihat dokumentasi aplikasi host.
s,StepInto: Menjalankan pernyataan berikutnya lalu berhenti.v,StepOver: Menjalankan pernyataan berikutnya, tetapi melewati fungsi dan pemanggilan. Pernyataan yang dilewati dijalankan, tetapi tidak dilangkahi.Ctrl+Break: (Break All in ISE) Membobol skrip yang sedang berjalan dalam konsol PowerShell, atau Windows PowerShell ISE. Perhatikan bahwa Ctrl+Break di Windows PowerShell 2.0, 3.0, dan 4.0 menutup program. Hentian Semua berfungsi pada skrip lokal dan jarak jauh yang berjalan secara interaktif.o,StepOut: Langkah-langkah keluar dari fungsi saat ini; naik satu tingkat jika berlapis. Jika dalam tubuh utama, itu berlanjut ke akhir atau titik henti berikutnya. Pernyataan yang dilewati dijalankan, tetapi tidak dilangkahi.c, :ContinueTerus berjalan hingga skrip selesai atau sampai titik henti berikutnya tercapai. Pernyataan yang dilewati dijalankan, tetapi tidak dilangkahi.l,List: Menampilkan bagian skrip yang sedang dijalankan. Secara default, baris ini menampilkan baris saat ini, lima baris sebelumnya, dan 10 baris berikutnya. Untuk melanjutkan mencantumkan skrip, tekan ENTER.l <m>,List: Menampilkan 16 baris skrip yang dimulai dengan nomor baris yang ditentukan oleh<m>.l <m> <n>,List: Menampilkan<n>baris skrip, dimulai dengan nomor baris yang ditentukan oleh<m>.q, ,StopExit: Berhenti menjalankan skrip, dan keluar dari debugger. Jika Anda men-debug pekerjaan dengan menjalankanDebug-Jobcmdlet,Exitperintah melepaskan debugger, dan memungkinkan pekerjaan untuk terus berjalan.k,Get-PsCallStack: Menampilkan tumpukan panggilan saat ini.<Enter>: Mengulangi perintah terakhir jika ituStep(s),StepOver(v), atauList(l). Jika tidak, mewakili tindakan kirim.?,h: Menampilkan Bantuan perintah debugger.
Untuk keluar dari debugger, Anda dapat menggunakan Stop (q).
Mulai dari PowerShell 5.0, Anda dapat menjalankan perintah Keluar untuk keluar dari sesi penelusuran kesalahan berlapis yang Anda mulai dengan menjalankan salah satu Debug-Job atau Debug-Runspace.
Dengan menggunakan perintah debugger ini, Anda dapat menjalankan skrip, berhenti pada titik perhatian, memeriksa nilai variabel dan status sistem, dan terus menjalankan skrip sampai Anda mengidentifikasi masalah.
Catatan
Jika Anda masuk ke pernyataan dengan operator pengalihan, seperti >, langkah-langkah debugger PowerShell di atas semua pernyataan yang tersisa dalam skrip.
Menampilkan nilai variabel skrip
Saat Anda berada di debugger, Anda juga dapat memasukkan perintah, menampilkan nilai variabel, menggunakan cmdlet, dan menjalankan skrip di baris perintah. Anda dapat menampilkan nilai saat ini dari semua variabel dalam skrip yang sedang di-debug, kecuali untuk variabel otomatis berikut:
$_
$Args
$Input
$MyInvocation
$PSBoundParameters
Saat Anda menampilkan nilai salah satu variabel ini, Anda mendapatkan nilai variabel tersebut untuk alur internal yang digunakan debugger, bukan nilai variabel dalam skrip.
Untuk menampilkan nilai variabel ini untuk skrip yang sedang di-debug, tambahkan baris ke skrip Anda untuk menyimpan nilai ini ke variabel baru. Atur titik henti Anda setelah baris baru ini. Kemudian Anda dapat menampilkan nilai variabel baru.
Contohnya,
$scriptArgs = $Args
$scriptname = $MyInvocation.PSCommandPath
Lingkungan debugger
Saat mencapai titik henti, Anda memasukkan lingkungan debugger. Prompt perintah berubah sehingga dimulai dengan "[DBG]:". Selain itu, di beberapa aplikasi host, seperti konsol PowerShell, perintah berlapis terbuka untuk penelusuran kesalahan. Anda dapat mendeteksi perintah berlapis dengan mengulangi karakter yang lebih besar dari (ASCII 62) yang muncul di prompt perintah.
Untuk informasi selengkapnya tentang menyesuaikan perintah, lihat about_Prompts.
Anda dapat menemukan tingkat berlapis dengan menggunakan $NestedPromptLevel variabel otomatis. Variabel otomatis, $PSDebugContext, didefinisikan dalam cakupan lokal. Anda dapat menggunakan keberadaan $PSDebugContext variabel untuk menentukan apakah Anda berjalan dalam debugger.
Contohnya:
if ($PSDebugContext) {"Debugging"} else {"Not Debugging"}
Anda dapat menggunakan nilai $PSDebugContext variabel dalam penelusuran kesalahan Anda.
[DBG]: PS>>> $PSDebugContext.InvocationInfo
Name CommandLineParameters UnboundArguments Location
---- --------------------- ---------------- --------
= {} {} C:\ps-test\vote.ps1 (1)
Penelusuran kesalahan dan cakupan
Memecah ke debugger tidak mengubah cakupan tempat Anda beroperasi, tetapi ketika Anda mencapai titik henti dalam skrip, Anda berpindah ke cakupan skrip. Cakupan skrip adalah anak dari cakupan tempat Anda menjalankan debugger.
Untuk menemukan variabel dan alias yang ditentukan dalam cakupan skrip, gunakan parameter Cakupan cmdlet Get-Alias atau Get-Variable .
Misalnya, perintah berikut mendapatkan variabel dalam cakupan lokal (skrip):
Get-Variable -scope 0
Ini adalah cara yang berguna untuk melihat hanya variabel yang Anda tentukan dalam skrip dan yang Anda tentukan saat penelusuran kesalahan.
Penelusuran kesalahan di baris perintah
Saat Anda mengatur titik henti variabel atau titik henti perintah, Anda hanya dapat mengatur titik henti dalam file skrip. Namun, secara default, titik henti diatur pada apa pun yang berjalan dalam sesi saat ini.
Misalnya, jika Anda mengatur titik henti pada $name variabel, debugger akan berhenti pada variabel apa pun $name dalam skrip, perintah, fungsi, cmdlet skrip, atau ekspresi apa pun yang Anda jalankan hingga Anda menonaktifkan atau menghapus titik henti.
Ini memungkinkan Anda untuk men-debug skrip Anda dalam konteks yang lebih realistis di mana skrip tersebut mungkin dipengaruhi oleh fungsi, variabel, dan skrip lainnya dalam sesi dan di profil pengguna.
Titik henti baris khusus untuk file skrip, sehingga hanya diatur dalam file skrip.
Fungsi penelusuran kesalahan
Saat Anda mengatur titik henti pada fungsi yang memiliki beginbagian , process, dan end , debugger berhenti di baris pertama setiap bagian.
Contohnya:
function test-cmdlet {
begin {
write-output "Begin"
}
process {
write-output "Process"
}
end {
write-output "End"
}
}
C:\PS> Set-PSBreakpoint -command test-cmdlet
C:\PS> test-cmdlet
Begin
Entering debug mode. Use h or ? for help.
Hit Command breakpoint on 'prompt:test-cmdlet'
test-cmdlet
[DBG]: C:\PS> c
Process
Entering debug mode. Use h or ? for help.
Hit Command breakpoint on 'prompt:test-cmdlet'
test-cmdlet
[DBG]: C:\PS> c
End
Entering debug mode. Use h or ? for help.
Hit Command breakpoint on 'prompt:test-cmdlet'
test-cmdlet
[DBG]: C:\PS>
Men-debug skrip jarak jauh
Anda dapat menjalankan Enter-PSSession untuk memulai sesi PowerShell jarak jauh interaktif di mana Anda dapat mengatur titik henti dan men-debug file dan perintah skrip di komputer jarak jauh. Enter-PSSession memungkinkan Anda menyambungkan kembali sesi terputus yang menjalankan skrip atau perintah di komputer jarak jauh. Jika skrip yang sedang berjalan mencapai titik henti, sesi klien Anda secara otomatis memulai debugger. Jika sesi terputus yang menjalankan skrip telah mencapai titik henti, Enter-PSSession secara otomatis memulai debugger baris perintah, saat Anda terhubung kembali ke sesi.
Contoh berikut menunjukkan cara kerjanya. Titik henti telah diatur pada baris 6, 11, 22, dan 25 skrip. Saat debugger dimulai, ada dua perubahan identifikasi pada perintah:
- Nama komputer tempat sesi berjalan
- Perintah DBG yang memungkinkan Anda mengetahui bahwa Anda berada dalam mode penelusuran kesalahan
Enter-PSSession -Cn localhost
[localhost]: PS C:\psscripts> Set-PSBreakpoint .\ttest19.ps1 6,11,22,25
ID Script Line Command Variable Action
-- ------ ---- ------- -------- ------
0 ttest19.ps1 6
1 ttest19.ps1 11
2 ttest19.ps1 22
3 ttest19.ps1 25
[localhost]: PS C:\psscripts> .\ttest19.ps1
Hit Line breakpoint on 'C:\psscripts\ttest19.ps1:11'
At C:\psscripts\ttest19.ps1:11 char:1
+ $winRMName = "WinRM"
# + ~
[localhost]: [DBG]: PS C:\psscripts>> list
6: 1..5 | foreach { sleep 1; Write-Output "hello2day $_" }
7: }
# 8:
9: $count = 10
10: $psName = "PowerShell"
11:* $winRMName = "WinRM"
12: $myVar = 102
# 13:
14: for ($i=0; $i -lt $count; $i++)
15: {
16: sleep 1
17: Write-Output "Loop iteration is: $i"
18: Write-Output "MyVar is $myVar"
# 19:
20: hello2day
# 21:
[localhost]: [DBG]: PS C:\psscripts>> stepover
At C:\psscripts\ttest19.ps1:12 char:1
+ $myVar = 102
# + ~
[localhost]: [DBG]: PS C:\psscripts>> quit
[localhost]: PS C:\psscripts> Exit-PSSession
PS C:\psscripts>
Contoh
Skrip pengujian ini mendeteksi versi PowerShell dan menampilkan pesan yang sesuai versi. Ini termasuk fungsi, panggilan fungsi, dan variabel.
Perintah berikut menampilkan konten file skrip pengujian:
PS C:\PS-test> Get-Content test.ps1
function psversion {
"PowerShell " + $PSVersionTable.PSVersion
if ($PSVersionTable.PSVersion.Major -lt 7) {
"Upgrade to PowerShell 7!"
}
else {
"Have you run a background job today (start-job)?"
}
}
$scriptName = $MyInvocation.PSCommandPath
psversion
"Done $scriptName."
Untuk memulai, atur titik henti pada titik minat dalam skrip, seperti baris, perintah, variabel, atau fungsi.
Mulailah dengan membuat titik henti baris pada baris pertama skrip Test.ps1 di direktori saat ini.
PS C:\ps-test> Set-PSBreakpoint -line 1 -script test.ps1
Perintah mengembalikan objek System.Management.Automation.LineBreakpoint .
Column : 0
Line : 1
Action :
Enabled : True
HitCount : 0
Id : 0
Script : C:\ps-test\test.ps1
ScriptName : C:\ps-test\test.ps1
Sekarang, mulai skrip.
PS C:\ps-test> .\test.ps1
Ketika skrip mencapai titik henti pertama, pesan titik henti menunjukkan bahwa debugger aktif. Ini menjelaskan titik henti dan mempratinjau baris pertama skrip, yang merupakan deklarasi fungsi. Prompt perintah juga berubah untuk menunjukkan bahwa debugger memiliki kontrol.
Baris pratinjau menyertakan nama skrip dan nomor baris perintah yang dipratinjau.
Entering debug mode. Use h or ? for help.
Hit Line breakpoint on 'C:\ps-test\test.ps1:1'
test.ps1:1 function psversion {
DBG>
Gunakan perintah Langkah untuk menjalankan pernyataan pertama dalam skrip dan untuk mempratinjau pernyataan berikutnya. Pernyataan berikutnya menggunakan $MyInvocation variabel otomatis untuk mengatur nilai $scriptName variabel ke jalur dan nama file file skrip.
DBG> s
test.ps1:11 $scriptName = $MyInvocation.PSCommandPath
Pada titik ini, $scriptName variabel tidak diisi, tetapi Anda dapat memverifikasi nilai variabel dengan menampilkan nilainya. Dalam hal ini, nilainya adalah $null.
DBG> $scriptname
DBG>
Gunakan perintah lain Step (s) untuk menjalankan pernyataan saat ini dan untuk mempratinjau pernyataan berikutnya dalam skrip. Pernyataan berikutnya memanggil psversion fungsi .
DBG> s
test.ps1:12 psversion
Pada titik ini, $scriptName variabel diisi, tetapi Anda memverifikasi nilai variabel dengan menampilkan nilainya. Dalam hal ini, nilai diatur ke jalur skrip.
DBG> $scriptName
C:\ps-test\test.ps1
Gunakan perintah Langkah lain untuk menjalankan panggilan fungsi. Tekan ENTER, atau ketik "s" untuk Langkah.
DBG> s
test.ps1:2 "PowerShell " + $PSVersionTable.PSVersion
Pesan debug menyertakan pratinjau pernyataan dalam fungsi . Untuk menjalankan pernyataan ini dan untuk mempratinjau pernyataan berikutnya dalam fungsi, Anda dapat menggunakan Step perintah. Tetapi, dalam hal ini, gunakan perintah StepOut (o). Ini menyelesaikan eksekusi fungsi (kecuali mencapai titik henti) dan langkah-langkah ke pernyataan berikutnya dalam skrip.
DBG> o
Windows PowerShell 2.0
Have you run a background job today (start-job)?
test.ps1:13 "Done $scriptName"
Karena kita berada di pernyataan terakhir dalam skrip, perintah Langkah, StepOut, dan Lanjutkan memiliki efek yang sama. Dalam hal ini, gunakan StepOut (o).
Done C:\ps-test\test.ps1
PS C:\ps-test>
Perintah StepOut menjalankan perintah terakhir. Prompt perintah standar menunjukkan bahwa debugger telah keluar dan mengembalikan kontrol ke prosesor perintah.
Sekarang, jalankan debugger lagi. Pertama, untuk menghapus titik henti saat ini, gunakan Get-PsBreakpoint cmdlet dan Remove-PsBreakpoint . (Jika Anda berpikir Anda mungkin menggunakan kembali titik henti, gunakan Disable-PsBreakpoint cmdlet alih-alih Remove-PsBreakpoint.)
PS C:\ps-test> Get-PSBreakpoint| Remove-PSBreakpoint
Anda dapat menyingkat perintah ini sebagai:
PS C:\ps-test> gbp | rbp
Atau, jalankan perintah dengan menulis fungsi, seperti fungsi berikut:
function delbr { gbp | rbp }
Sekarang, buat titik henti pada $scriptname variabel .
PS C:\ps-test> Set-PSBreakpoint -variable scriptname -script test.ps1
Anda dapat menyingkat perintah sebagai:
PS C:\ps-test> sbp -v scriptname -s test.ps1
Sekarang, mulai skrip. Skrip mencapai titik henti variabel. Mode default adalah Tulis, sehingga eksekusi berhenti tepat sebelum pernyataan yang mengubah nilai variabel.
PS C:\ps-test> .\test.ps1
Hit Variable breakpoint on 'C:\ps-test\test.ps1:$scriptName'
(Write access)
test.ps1:11 $scriptName = $MyInvocation.PSCommandPath
DBG>
Tampilkan nilai $scriptName variabel saat ini, yaitu $null.
DBG> $scriptName
DBG>
Step Gunakan perintah (s) untuk menjalankan pernyataan yang mengisi variabel. Kemudian, tampilkan nilai $scriptName baru variabel.
DBG> $scriptName
C:\ps-test\test.ps1
Gunakan perintah Langkah untuk mempratinjau pernyataan berikutnya dalam skrip.
DBG> s
test.ps1:12 psversion
Pernyataan berikutnya adalah panggilan ke psversion fungsi . Untuk melewati fungsi tetapi masih menjalankannya, gunakan StepOver perintah (v). Jika Anda sudah berada dalam fungsi saat anda menggunakan StepOver, itu tidak efektif. Panggilan fungsi ditampilkan, tetapi tidak dijalankan.
DBG> v
Windows PowerShell 2.0
Have you run a background job today (start-job)?
test.ps1:13 "Done $scriptName"
Perintah StepOver menjalankan fungsi, dan mempratinjau pernyataan berikutnya dalam skrip, yang mencetak baris akhir.
Stop Gunakan perintah (t) untuk keluar dari debugger. Prompt perintah kembali ke prompt perintah standar.
C:\ps-test>
Untuk menghapus titik henti, gunakan Get-PsBreakpoint cmdlet dan Remove-PsBreakpoint .
PS C:\ps-test> Get-PSBreakpoint| Remove-PSBreakpoint
Buat titik henti perintah baru pada psversion fungsi .
PS C:\ps-test> Set-PSBreakpoint -command psversion -script test.ps1
Anda dapat menyingkat perintah ini untuk:
PS C:\ps-test> sbp -c psversion -s test.ps1
Sekarang, jalankan skrip.
PS C:\ps-test> .\test.ps1
Hit Command breakpoint on 'C:\ps-test\test.ps1:psversion'
test.ps1:12 psversion
DBG>
Skrip mencapai titik henti pada panggilan fungsi. Pada titik ini, fungsi belum dipanggil. Ini memberi Anda kesempatan untuk menggunakan parameter Set-PSBreakpoint Tindakan untuk mengatur kondisi untuk eksekusi titik henti atau untuk melakukan tugas persiapan atau diagnostik, seperti memulai log atau memanggil skrip diagnostik atau keamanan.
Untuk mengatur tindakan, gunakan perintah Lanjutkan (c) untuk keluar dari skrip, dan Remove-PsBreakpoint perintah untuk menghapus titik henti saat ini. (Titik henti bersifat baca-saja, sehingga Anda tidak dapat menambahkan tindakan ke titik henti saat ini.)
DBG> c
Windows PowerShell 2.0
Have you run a background job today (start-job)?
Done C:\ps-test\test.ps1
PS C:\ps-test> Get-PSBreakpoint| Remove-PSBreakpoint
PS C:\ps-test>
Sekarang, buat titik henti perintah baru dengan tindakan. Perintah berikut mengatur titik henti perintah dengan tindakan yang mencatat nilai $scriptName variabel saat fungsi dipanggil. break Karena kata kunci tidak digunakan dalam tindakan, eksekusi tidak berhenti. Backtick (`) adalah karakter kelanjutan baris.
PS C:\ps-test> Set-PSBreakpoint -command psversion -script test.ps1 `
-action { add-content "The value of `$scriptName is $scriptName." `
-path action.log}
Anda juga dapat menambahkan tindakan yang mengatur kondisi untuk titik henti. Dalam perintah berikut, titik henti perintah dijalankan hanya jika kebijakan eksekusi diatur ke RemoteSigned, kebijakan paling ketat yang masih memungkinkan Anda menjalankan skrip.
PS C:\ps-test> Set-PSBreakpoint -script test.ps1 -command psversion `
-action { if ((Get-ExecutionPolicy) -eq "RemoteSigned") { break }}
Kata break kunci dalam tindakan mengarahkan debugger untuk menjalankan titik henti. Anda juga dapat menggunakan continue kata kunci untuk mengarahkan debugger untuk dijalankan tanpa melanggar. Karena kata kunci default adalah continue, Anda harus menentukan break untuk menghentikan eksekusi.
Sekarang, jalankan skrip.
PS C:\ps-test> .\test.ps1
Hit Command breakpoint on 'C:\ps-test\test.ps1:psversion'
test.ps1:12 psversion
Karena kebijakan eksekusi diatur ke RemoteSigned, eksekusi berhenti pada panggilan fungsi.
Pada titik ini, Anda mungkin ingin memeriksa tumpukan panggilan. Get-PsCallStack Gunakan cmdlet atau Get-PsCallStack perintah debugger (k). Perintah berikut mendapatkan tumpukan panggilan saat ini.
DBG> k
2: prompt
1: .\test.ps1: $args=[]
0: prompt: $args=[]
Contoh ini menunjukkan hanya beberapa dari banyak cara untuk menggunakan debugger PowerShell.
Fitur Penelusuran Kesalahan Lainnya di PowerShell
Selain debugger PowerShell, PowerShell menyertakan beberapa fitur lain yang dapat Anda gunakan untuk men-debug skrip dan fungsi.
Set-PSDebugCmdlet menawarkan fitur penelusuran kesalahan skrip yang sangat dasar, termasuk melangkah dan melacak.Set-StrictModeGunakan cmdlet untuk mendeteksi referensi ke variabel yang tidak diinisialisasi, untuk mereferensikan ke properti objek yang tidak ada, dan untuk memfungsikan sintaksis yang tidak valid.Tambahkan pernyataan diagnostik ke skrip, seperti pernyataan yang menampilkan nilai variabel, pernyataan yang membaca input dari baris perintah, atau pernyataan yang melaporkan instruksi saat ini. Gunakan cmdlet yang berisi kata kerja Tulis untuk tugas ini, seperti
Write-Host, ,Write-DebugWrite-Warning, danWrite-Verbose.
Lihat juga
Saran dan Komentar
Segera hadir: Sepanjang tahun 2024 kami akan menghentikan penggunaan GitHub Issues sebagai mekanisme umpan balik untuk konten dan menggantinya dengan sistem umpan balik baru. Untuk mengetahui informasi selengkapnya, lihat: https://aka.ms/ContentUserFeedback.
Kirim dan lihat umpan balik untuk