Udostępnij za pośrednictwem

Informacje o debugerach

  • Artykuł

KRÓTKI OPIS

Opisuje debuger programu PowerShell.

DŁUGI OPIS

Debugowanie to proces badania skryptu podczas uruchamiania w celu identyfikowania i poprawiania błędów w instrukcjach skryptu. Debuger programu PowerShell może pomóc w przeanalizować i zidentyfikować błędy i nieefektywność w skryptach, funkcjach, poleceniach, przepływach pracy programu PowerShell, konfiguracjach programu PowerShell Desired State Configuration (DSC) lub wyrażeniach.

Począwszy od programu PowerShell 5.0 debuger programu PowerShell został zaktualizowany do debugowania skryptów, funkcji, przepływów pracy, poleceń, konfiguracji lub wyrażeń uruchomionych w konsoli programu lub Windows PowerShell ISE na komputerach zdalnych. Możesz uruchomić polecenie , aby uruchomić Enter-PSSession interaktywną zdalną sesję programu PowerShell, w której można ustawić punkty przerwania i debugować pliki skryptów i polecenia na komputerze zdalnym. Enter-PSSession Funkcja została zaktualizowana, aby umożliwić ponowne nawiązywanie połączenia i wprowadzanie rozłączonej sesji, która uruchamia skrypt lub polecenie na komputerze zdalnym. Jeśli uruchomiony skrypt osiągnie punkt przerwania, sesja klienta automatycznie uruchamia debuger. Jeśli rozłączona sesja, w której jest uruchomiony skrypt, osiągnęła już punkt przerwania i zostanie zatrzymana w punkcie przerwania, Enter-PSSession automatycznie uruchomi debuger wiersza polecenia po ponownym nawiązaniu połączenia z sesją.

Debuger programu PowerShell może również służyć do debugowania przepływów pracy programu PowerShell w konsoli programu PowerShell lub w programie Windows PowerShell ISE. Począwszy od programu PowerShell 5.0, można debugować w ramach uruchomionych zadań lub procesów lokalnie lub zdalnie.

Funkcje debugera programu PowerShell umożliwiają sprawdzenie skryptu programu PowerShell, funkcji, polecenia, przepływu pracy lub wyrażenia podczas jego działania. Debuger programu PowerShell zawiera zestaw poleceń cmdlet, które umożliwiają ustawianie punktów przerwania, zarządzanie punktami przerwania i wyświetlanie stosu wywołań.

Polecenia cmdlet debugera

Debuger programu PowerShell zawiera następujący zestaw poleceń cmdlet:

  • Set-PSBreakpoint: ustawia punkty przerwania w wierszach, zmiennych i poleceniach.
  • Get-PSBreakpoint: pobiera punkty przerwania w bieżącej sesji.
  • Disable-PSBreakpoint: wyłącza punkty przerwania w bieżącej sesji.
  • Enable-PSBreakpoint: Ponownie włącza punkty przerwania w bieżącej sesji.
  • Remove-PSBreakpoint: usuwa punkty przerwania z bieżącej sesji.
  • Get-PSCallStack: wyświetla bieżący stos wywołań.

Uruchamianie i zatrzymywanie debugera

Aby uruchomić debuger, ustaw co najmniej jeden punkt przerwania. Następnie uruchom skrypt, polecenie lub funkcję, którą chcesz debugować.

Po osiągnięciu punktu przerwania wykonywanie zostanie zatrzymane, a kontrolka zostanie przekazana do debugera.

Aby zatrzymać debuger, uruchom skrypt, polecenie lub funkcję, dopóki nie zostanie ukończona. Lub, wpisz stop lub t.

Polecenia debugera

W przypadku korzystania z debugera w konsoli programu PowerShell użyj następujących poleceń, aby kontrolować wykonywanie. W Windows PowerShell ISE użyj poleceń w menu Debugowanie.

Uwaga: Aby uzyskać informacje o sposobie używania debugera w innych aplikacjach hosta, zobacz dokumentację aplikacji hosta.

  • s, StepInto: wykonuje następną instrukcję, a następnie zatrzymuje.

  • v, StepOver: wykonuje następną instrukcję, ale pomija funkcje i wywołania. Pominięte instrukcje są wykonywane, ale nie są wykonywane.

  • Ctrl+Break: (Przerwij wszystko w środowisku ISE) Dzieli się na uruchomiony skrypt w konsoli programu PowerShell lub Windows PowerShell ISE. Należy pamiętać, że klawisze Ctrl+Break w Windows PowerShell 2.0, 3.0 i 4.0 zamyka program. Break All działa zarówno na skryptach lokalnych, jak i zdalnych działających interaktywnie.

  • o, StepOut: Wychodzi z bieżącej funkcji; w górę jeden poziom, jeśli jest zagnieżdżony. Jeśli w treści głównej, będzie ona kontynuowana na końcu lub następnym punkcie przerwania. Pominięte instrukcje są wykonywane, ale nie są wykonywane.

  • c, Continue: kontynuuje działanie do momentu ukończenia skryptu lub do momentu osiągnięcia następnego punktu przerwania. Pominięte instrukcje są wykonywane, ale nie są wykonywane.

  • l, List: wyświetla część wykonywanego skryptu. Domyślnie wyświetla bieżący wiersz, pięć poprzednich wierszy i 10 kolejnych wierszy. Aby kontynuować wyświetlanie listy skryptu, naciśnij klawisz ENTER.

  • l <m>, List: wyświetla 16 wierszy skryptu rozpoczynających się od numeru wiersza określonego przez <m>.

  • l <m> <n>, List: wyświetla wiersze <n> skryptu, począwszy od numeru wiersza określonego przez <m>.

  • q, , StopExit: zatrzymuje wykonywanie skryptu i kończy debuger. Jeśli debugujesz zadanie, uruchamiając Debug-Job polecenie cmdlet, Exit polecenie odłącza debuger i umożliwia kontynuowanie działania zadania.

  • k, Get-PsCallStack: wyświetla bieżący stos wywołań.

  • <Enter>: powtarza ostatnie polecenie, jeśli to krok (s), krok (v) lub lista (l). W przeciwnym razie reprezentuje akcję przesyłania.

  • ?, h: wyświetla pomoc polecenia debugera.

Aby zamknąć debuger, możesz użyć polecenia Zatrzymaj (q).

Począwszy od programu PowerShell 5.0, możesz uruchomić polecenie Exit, aby zamknąć sesję debugowania zagnieżdżonego, która została uruchomiona, uruchamiając Debug-Job polecenie lub Debug-Runspace.

Korzystając z tych poleceń debugera, można uruchomić skrypt, zatrzymać się w punkcie obawy, zbadać wartości zmiennych i stan systemu i kontynuować uruchamianie skryptu, dopóki nie zidentyfikowano problemu.

UWAGA: Jeśli wchodzisz do instrukcji z operatorem przekierowania, takim jak ">", debuger programu PowerShell przechodzi przez wszystkie pozostałe instrukcje w skrypcie.

Wyświetlanie wartości zmiennych skryptu

Gdy jesteś w debugerze, możesz również wprowadzić polecenia, wyświetlić wartość zmiennych, użyć poleceń cmdlet i uruchomić skrypty w wierszu polecenia.

Bieżącą wartość wszystkich zmiennych można wyświetlić w skryptie, który jest debugowany, z wyjątkiem następujących zmiennych automatycznych:

$_
$Args
$Input
$MyInvocation
$PSBoundParameters

Jeśli spróbujesz wyświetlić wartość dowolnej z tych zmiennych, uzyskasz wartość tej zmiennej dla w wewnętrznym potoku używanym przez debuger, a nie wartość zmiennej w skrycie.

Aby wyświetlić wartość tych zmiennych dla skryptu, który jest debugowany, w skryscie przypisz wartość zmiennej automatycznej do nowej zmiennej. Następnie możesz wyświetlić wartość nowej zmiennej.

Na przykład

$scriptArgs = $Args
$scriptArgs

W przykładzie w tym temacie wartość zmiennej $MyInvocation jest ponownie przypisywana w następujący sposób:

$scriptname = $MyInvocation.MyCommand.Path

Środowisko debugera

Po osiągnięciu punktu przerwania należy wprowadzić środowisko debugera. Wiersz polecenia zmienia się tak, aby rozpoczynał się od ciągu "[DBG]:". Jeśli debugujesz przepływ pracy, monit to "[WFDBG]". Możesz dostosować monit.

Aby uzyskać więcej informacji na temat dostosowywania monitu, zobacz about_Prompts.

Ponadto w niektórych aplikacjach hosta, takich jak konsola programu PowerShell (ale nie w Windows PowerShell zintegrowanego środowiska skryptów [ISE]), zostanie otwarty zagnieżdżony monit do debugowania. Możesz wykryć zagnieżdżony wiersz, powtarzając się więcej niż znaki (ASCII 62), które są wyświetlane w wierszu polecenia.

Na przykład poniżej przedstawiono domyślny monit debugowania w konsoli programu PowerShell:

[DBG]: PS (get-location)>>>

Poziom zagnieżdżania można znaleźć przy użyciu zmiennej automatycznej $NestedPromptLevel .

Ponadto zmienna $PSDebugContextautomatyczna , jest definiowana w zakresie lokalnym. Możesz użyć obecności zmiennej $PsDebugContext , aby określić, czy jesteś w debugerze.

Na przykład:

if ($PSDebugContext) {"Debugging"} else {"Not Debugging"}

Możesz użyć wartości zmiennej $PSDebugContext w debugowaniu.

[DBG]: PS>>> $PSDebugContext.InvocationInfo

Name   CommandLineParameters  UnboundArguments  Location
----   ---------------------  ----------------  --------
=      {}                     {}                C:\ps-test\vote.ps1 (1)

Debugowanie i zakres

Podział na debuger nie zmienia zakresu, w którym działasz, ale po osiągnięciu punktu przerwania w skrycie przechodzisz do zakresu skryptu. Zakres skryptu jest elementem podrzędnym zakresu, w którym uruchomiono debuger.

Aby znaleźć zmienne i aliasy zdefiniowane w zakresie skryptu, użyj parametru Get-Alias Zakres poleceń cmdlet lub Get-Variable .

Na przykład następujące polecenie pobiera zmienne w zakresie lokalnego (skryptu):

Get-Variable -scope 0

Możesz skrócić polecenie jako:

gv -s 0

Jest to przydatny sposób wyświetlenia tylko zmiennych zdefiniowanych w skrycie i zdefiniowanych podczas debugowania.

Debugowanie w wierszu polecenia

Po ustawieniu punktu przerwania zmiennej lub punktu przerwania polecenia można ustawić punkt przerwania tylko w pliku skryptu. Jednak domyślnie punkt przerwania jest ustawiany na wszystkich elementach uruchamianych w bieżącej sesji.

Jeśli na przykład ustawisz punkt przerwania dla zmiennej $name , debuger przerywa działanie dowolnej zmiennej w dowolnym $name skrycie, poleceniu, funkcji, poleceniu cmdlet skryptu lub wyrażeniu uruchamianym do momentu wyłączenia lub usunięcia punktu przerwania.

Umożliwia to debugowanie skryptów w bardziej realistycznym kontekście, na który mogą mieć wpływ funkcje, zmienne i inne skrypty w sesji oraz w profilu użytkownika.

Punkty przerwania wiersza są specyficzne dla plików skryptów, dlatego są ustawiane tylko w plikach skryptów.

Debugowanie przepływów pracy

Debuger programu PowerShell 4.0 może służyć do debugowania przepływów pracy programu PowerShell w konsoli programu PowerShell lub w środowisku Windows PowerShell ISE. Istnieją pewne ograniczenia dotyczące debugera programu PowerShell do debugowania przepływów pracy.

  • Zmienne przepływu pracy można wyświetlać, gdy jesteś w debugerze, ale ustawienie zmiennych przepływu pracy z poziomu debugera nie jest obsługiwane.
  • Ukończenie karty po zatrzymaniu w debugerze przepływu pracy jest niedostępne.
  • Debugowanie przepływu pracy działa tylko z synchronicznym uruchamianiem przepływów pracy ze skryptu programu PowerShell. Nie można debugować przepływów pracy, jeśli są one uruchomione jako zadanie (z parametrem AsJob ).
  • Inne zagnieżdżone scenariusze debugowania, takie jak przepływ pracy wywołujący inny przepływ pracy lub przepływ pracy wywołujący skrypt, nie są implementowane.

W poniższym przykładzie pokazano debugowanie przepływu pracy. Gdy debuger przechodzi do funkcji przepływu pracy, debuger monituje o zmianę na "[WFDBG]".

PS C:> Set-PSBreakpoint -Script C:\TestWFDemo1.ps1 -Line 8

ID Script           Line Command    Variable     Action
-- ------           ---- -------    --------     ------
0 TestWFDemo1.ps1   8

PS C:> C:\TestWFDemo1.ps1
Entering debug mode. Use h or ? for help.

Hit Line breakpoint on 'C:\TestWFDemo1.ps1:8'

At C:\TestWFDemo1.ps1:8 char:5
+     Write-Output -InputObject "Now writing output:"
# +!INCLUDE[]~~~~~

[WFDBG:localhost]: PS C:>> list

# 3:

4:  workflow SampleWorkflowTest
5:  {
6:      param ($MyOutput)
# 7:

8:*     Write-Output -InputObject "Now writing output:"
9:      Write-Output -Input $MyOutput
# 10:

11:      Write-Output -InputObject "Get PowerShell process:"
12:      Get-Process -Name powershell
# 13:

14:      Write-Output -InputObject "Workflow function complete."
15:  }
# 16:

17:  # Call workflow function
18:  SampleWorkflowTest -MyOutput "Hello"

[WFDBG:localhost]: PS C:>> $MyOutput
Hello
[WFDBG:localhost]: PS C:>> stepOver
Now writing output:
At C:\TestWFDemo1.ps1:9 char:5
+     Write-Output -Input $MyOutput
# +!INCLUDE[]~

[WFDBG:localhost]: PS C:>> list

4:  workflow SampleWorkflowTest
5:  {
6:      param ($MyOutput)
# 7:

8:      Write-Output -InputObject "Now writing output:"
9:*     Write-Output -Input $MyOutput
# 10:

11:      Write-Output -InputObject "Get PowerShell process:"
12:      Get-Process -Name powershell
# 13:

14:      Write-Output -InputObject "Workflow function complete."
15:  }
# 16:

17:  # Call workflow function
18:  SampleWorkflowTest -MyOutput "Hello"
# 19:


[WFDBG:localhost]: PS C:>> stepOver
Hello
At C:\TestWFDemo1.ps1:11 char:5
+     Write-Output -InputObject "Get PowerShell process:"
# +!INCLUDE[]~~~~~~~~~

[WFDBG:localhost]: PS C:>> stepOut
Get PowerShell process:

Handles  NPM(K)    PM(K)    WS(K) VM(M)   CPU(s)     Id ProcessName
-------  ------    -----    ----- -----   ------     -- -----------
    433      35   106688   128392   726     2.67   7124 powershell
    499      44   134244   172096   787     2.79   7452 powershell

Workflow function complete.

Funkcje debugowania

Po ustawieniu punktu przerwania w funkcji zawierającej Beginsekcje , Processi End debuger przerywa działanie w pierwszym wierszu każdej sekcji.

Na przykład:

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>

Debugowanie skryptów zdalnych

Począwszy od programu PowerShell 5.0, można uruchomić debuger programu PowerShell w sesji zdalnej w konsoli programu lub Windows PowerShell ISE. Enter-PSSession Funkcja została zaktualizowana, aby umożliwić ponowne nawiązywanie połączenia i wprowadzanie rozłączonej sesji, która jest uruchomiona na komputerze zdalnym i obecnie uruchamia skrypt. Jeśli uruchomiony skrypt osiągnie punkt przerwania, sesja klienta automatycznie uruchamia debuger.

Poniżej przedstawiono przykład, który pokazuje, jak to działa, z punktami przerwania ustawionymi w skryptach w wierszach 6, 11, 22 i 25. Zwróć uwagę, że w przykładzie po uruchomieniu debugera istnieją dwa monity identyfikujące: nazwę komputera, na którym jest uruchomiona sesja, oraz monit grupy DBG informujący o tym, że jesteś w trybie debugowania.

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>

Przykłady

Ten skrypt testowy wykrywa wersję systemu operacyjnego i wyświetla komunikat odpowiedni dla systemu. Obejmuje ona funkcję, wywołanie funkcji i zmienną.

Następujące polecenie wyświetla zawartość pliku skryptu testowego:

PS C:\PS-test>  Get-Content test.ps1

function psversion {
  "PowerShell " + $PSVersionTable.PSVersion
  if ($PSVersionTable.PSVersion.Major -lt 6) {
    "Upgrade to PowerShell 6.0!"
  }
  else {
    "Have you run a background job today (start-job)?"
  }
}

$scriptName = $MyInvocation.MyCommand.Path
psversion
"Done $scriptName."

Aby rozpocząć, ustaw punkt przerwania w punkcie orientacyjnym skryptu, taki jak wiersz, polecenie, zmienna lub funkcja.

Zacznij od utworzenia punktu przerwania wiersza w pierwszym wierszu skryptu Test.ps1 w bieżącym katalogu.

PS C:\ps-test> Set-PSBreakpoint -line 1 -script test.ps1

To polecenie można skrócić jako:

PS C:\ps-test> spb 1 -s test.ps1

Polecenie zwraca obiekt punktu przerwania wiersza (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

Teraz uruchom skrypt.

PS C:\ps-test> .\test.ps1

Gdy skrypt osiągnie pierwszy punkt przerwania, komunikat punktu przerwania wskazuje, że debuger jest aktywny. Opisuje on punkt przerwania i wyświetla podgląd pierwszego wiersza skryptu, który jest deklaracją funkcji. Wiersz polecenia również zmienia się, aby wskazać, że debuger ma kontrolę.

Wiersz podglądu zawiera nazwę skryptu i numer wiersza podglądu polecenia.

Entering debug mode. Use h or ? for help.

Hit Line breakpoint on 'C:\ps-test\test.ps1:1'

test.ps1:1   function psversion {
# DBG>

Użyj polecenia Krok (s), aby wykonać pierwszą instrukcję w skrycie i wyświetlić podgląd następnej instrukcji. Następna instrukcja używa zmiennej automatycznej $MyInvocation , aby ustawić wartość $scriptName zmiennej na ścieżkę i nazwę pliku skryptu.

DBG> s
test.ps1:11  $scriptName = $MyInvocation.MyCommand.Path

W tym momencie zmienna $scriptName nie jest wypełniana, ale można sprawdzić wartość zmiennej, wyświetlając jej wartość. W tym przypadku wartość to $null.

DBG> $scriptname
# DBG>

Użyj innego polecenia krok (s), aby wykonać bieżącą instrukcję i wyświetlić podgląd następnej instrukcji w skrycie. Następna instrukcja wywołuje funkcję PsVersion.

DBG> s
test.ps1:12  psversion

W tym momencie zmienna $scriptName jest wypełniana, ale sprawdzasz wartość zmiennej, wyświetlając jej wartość. W takim przypadku wartość jest ustawiona na ścieżkę skryptu.

DBG> $scriptName
C:\ps-test\test.ps1

Użyj innego polecenia Krok, aby wykonać wywołanie funkcji. Naciśnij klawisz ENTER lub wpisz "s" dla kroku.

DBG> s
test.ps1:2       "PowerShell " + $PSVersionTable.PSVersion

Komunikat debugowania zawiera podgląd instrukcji w funkcji. Aby wykonać tę instrukcję i wyświetlić podgląd następnej instrukcji w funkcji, możesz użyć Step polecenia . Jednak w tym przypadku użyj polecenia StepOut (o). Kończy wykonywanie funkcji (chyba że osiągnie punkt przerwania) i wykonuje kroki do następnej instrukcji w skry skrycie.

DBG> o
Windows PowerShell 2.0
Have you run a background job today (start-job)?
test.ps1:13  "Done $scriptName"

Ponieważ używamy ostatniej instrukcji skryptu, polecenia Krok, StepOut i Continue mają taki sam efekt. W takim przypadku użyj opcji StepOut (o).

Done C:\ps-test\test.ps1
PS C:\ps-test>

Polecenie StepOut wykonuje ostatnie polecenie. Standardowy wiersz polecenia wskazuje, że debuger zakończył działanie i zwrócił kontrolę do procesora poleceń.

Teraz ponownie uruchom debuger. Najpierw, aby usunąć bieżący punkt przerwania, użyj Get-PSBreakpoint poleceń cmdlet i Remove-PSBreakpoint . (Jeśli uważasz, że możesz ponownie użyć punktu przerwania, użyj Disable-PSBreakpoint polecenia cmdlet zamiast Remove-PSBreakpoint.

PS C:\ps-test> Get-PSBreakpoint| Remove-PSBreakpoint

To polecenie można skrócić jako:

PS C:\ps-test> gbp | rbp

Możesz też uruchomić polecenie, pisząc funkcję, taką jak następująca funkcja:

function delbr { gbp | rbp }

Teraz utwórz punkt przerwania dla zmiennej $scriptname .

PS C:\ps-test> Set-PSBreakpoint -variable scriptname -script test.ps1

Możesz skrócić polecenie jako:

PS C:\ps-test> sbp -v scriptname -s test.ps1

Teraz uruchom skrypt. Skrypt dociera do punktu przerwania zmiennej. Tryb domyślny to Zapis, więc wykonanie zatrzymuje się tuż przed instrukcją, która zmienia wartość zmiennej.

PS C:\ps-test> .\test.ps1
Hit Variable breakpoint on 'C:\ps-test\test.ps1:$scriptName'
(Write access)

test.ps1:11  $scriptName = $MyInvocation.MyCommand.Path
# DBG>

Wyświetl bieżącą wartość zmiennej $scriptName , czyli $null.

DBG> $scriptName
# DBG>

Użyj polecenia krok (s), aby wykonać instrukcję, która wypełnia zmienną. Następnie wyświetl nową wartość zmiennej $scriptName .

DBG> $scriptName
C:\ps-test\test.ps1
```powershell

Use a Step command (s) to preview the next statement in the script.

```powershell
DBG> s
test.ps1:12  psversion

Następna instrukcja jest wywołaniem funkcji PsVersion. Aby pominąć funkcję, ale nadal ją wykonać, użyj polecenia StepOver (v). Jeśli jesteś już w funkcji podczas korzystania z funkcji StepOver, nie jest to skuteczne. Zostanie wyświetlone wywołanie funkcji, ale nie jest wykonywane.

DBG> v
Windows PowerShell 2.0
Have you run a background job today (start-job)?
test.ps1:13  "Done $scriptName"

Polecenie StepOver wykonuje funkcję i wyświetla podgląd następnej instrukcji w skrycie, która wyświetla ostatni wiersz.

Użyj polecenia Stop (t), aby zamknąć debuger. Wiersz polecenia powraca do standardowego wiersza polecenia.

C:\ps-test>

Aby usunąć punkty przerwania, użyj Get-PSBreakpoint poleceń cmdlet i Remove-PSBreakpoint .

PS C:\ps-test> Get-PSBreakpoint| Remove-PSBreakpoint

Twórca nowy punkt przerwania polecenia w funkcji PsVersion.

PS C:\ps-test> Set-PSBreakpoint -command psversion -script test.ps1

To polecenie można skrócić do:

PS C:\ps-test> sbp -c psversion -s test.ps1

Teraz uruchom skrypt.

PS C:\ps-test> .\test.ps1
Hit Command breakpoint on 'C:\ps-test\test.ps1:psversion'

test.ps1:12  psversion
# DBG>

Skrypt dociera do punktu przerwania w wywołaniu funkcji. W tym momencie funkcja nie została jeszcze wywołana. Daje to możliwość użycia parametru Set-PSBreakpoint Akcja w celu ustawienia warunków wykonywania punktu przerwania lub wykonywania zadań przygotowawczych lub diagnostycznych, takich jak uruchamianie dziennika lub wywoływanie skryptu diagnostycznego lub zabezpieczeń.

Aby ustawić akcję, użyj polecenia Kontynuuj (c), aby zamknąć skrypt, i Remove-PSBreakpoint polecenie w celu usunięcia bieżącego punktu przerwania. (Punkty przerwania są tylko do odczytu, więc nie można dodać akcji do bieżącego punktu przerwania).

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>

Teraz utwórz nowy punkt przerwania polecenia z akcją. Następujące polecenie ustawia punkt przerwania polecenia z akcją, która rejestruje wartość $scriptName zmiennej po wywołaniu funkcji. Ponieważ słowo kluczowe Break nie jest używane w akcji, wykonanie nie jest zatrzymywane. (Backtick (') jest znakiem kontynuacji wiersza.

PS C:\ps-test> Set-PSBreakpoint -command psversion -script test.ps1  `
-action { add-content "The value of `$scriptName is $scriptName." `
-path action.log}

Możesz również dodać akcje, które ustawiają warunki punktu przerwania. W poniższym poleceniu punkt przerwania polecenia jest wykonywany tylko wtedy, gdy zasady wykonywania są ustawione na RemoteSigned, najbardziej restrykcyjne zasady, które nadal zezwalają na uruchamianie skryptów. (Backtick (') jest znakiem kontynuacji.

PS C:\ps-test> Set-PSBreakpoint -script test.ps1 -command psversion `
-action { if ((Get-ExecutionPolicy) -eq "RemoteSigned") { break }}

Słowo kluczowe Break w akcji kieruje debuger do wykonania punktu przerwania. Możesz również użyć słowa kluczowego Continue, aby skierować debuger do wykonania bez przerywania. Ponieważ domyślnym słowem kluczowym jest Kontynuuj, należy określić wartość Przerwanie, aby zatrzymać wykonywanie.

Teraz uruchom skrypt.

PS C:\ps-test> .\test.ps1
Hit Command breakpoint on 'C:\ps-test\test.ps1:psversion'

test.ps1:12  psversion

Ponieważ zasady wykonywania są ustawione na RemoteSigned, wykonanie zatrzymuje się na wywołaniu funkcji.

W tym momencie warto sprawdzić stos wywołań. Get-PsCallStack Użyj polecenia cmdlet lub Get-PsCallStack debugera (k). Następujące polecenie pobiera bieżący stos wywołań.

DBG> k
2: prompt
1: .\test.ps1: $args=[]
0: prompt: $args=[]

W tym przykładzie pokazano tylko kilka z wielu sposobów używania debugera programu PowerShell.

Aby uzyskać więcej informacji na temat poleceń cmdlet debugera, wpisz następujące polecenie:

help <cmdlet-name> -full

Na przykład wpisz:

help Set-PSBreakpoint -full

Inne funkcje debugowania w programie PowerShell

Oprócz debugera programu PowerShell program PowerShell zawiera kilka innych funkcji, których można użyć do debugowania skryptów i funkcji.

  • Windows PowerShell ISE zawiera interaktywny debuger graficzny. Aby uzyskać więcej informacji, uruchom Windows PowerShell ISE i naciśnij klawisz F1.

  • Polecenie Set-PSDebug cmdlet oferuje bardzo podstawowe funkcje debugowania skryptów, w tym wykonywanie kroków i śledzenie.

  • Set-StrictMode Za pomocą polecenia cmdlet można wykrywać odwołania do niezainicjowanych zmiennych, odwoływać się do nieistniejących właściwości obiektu oraz składni funkcji, która jest nieprawidłowa.

  • Dodaj instrukcje diagnostyczne do skryptu, takie jak instrukcje, które wyświetlają wartość zmiennych, instrukcje odczytujące dane wejściowe z wiersza polecenia lub instrukcje raportujące bieżącą instrukcję. Użyj poleceń cmdlet zawierających czasownik Write dla tego zadania, na przykład Write-Host, Write-Debug, Write-Warningi Write-Verbose.

ZOBACZ TEŻ