Bagikan melalui

about_Debuggers

  • Artikel

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 menjalankan Debug-Job cmdlet, Exit perintah melepaskan debugger, dan memungkinkan pekerjaan untuk terus berjalan.

  • k, Get-PsCallStack: Menampilkan tumpukan panggilan saat ini.

  • <Enter>: Mengulangi perintah terakhir jika itu Step (s), StepOver (v), atau List (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-PSDebug Cmdlet menawarkan fitur penelusuran kesalahan skrip yang sangat dasar, termasuk melangkah dan melacak.

  • Set-StrictMode Gunakan 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, dan Write-Verbose.

Lihat juga