Informacje o debugerachAbout Debuggers

KRÓTKI OPISSHORT DESCRIPTION

Opisuje debuger programu PowerShell.Describes the PowerShell debugger.

DŁUGI OPISLONG DESCRIPTION

Debugowanie jest procesem analizowania skryptu, gdy jest on uruchomiony, aby identyfikować i poprawiać błędy w instrukcjach dotyczących skryptu.Debugging is the process of examining a script while it is running to identify and correct errors in the script instructions. Debuger programu PowerShell może pomóc w sprawdzeniu i identyfikowaniu błędów oraz nieefektywności w skryptach, funkcjach, poleceniach, konfiguracjach żądanego stanu (DSC) programu PowerShell lub w wyrażeniach.The PowerShell debugger can help you examine and identify errors and inefficiencies in your scripts, functions, commands, PowerShell Desired State Configuration (DSC) configurations, or expressions.

Począwszy od programu PowerShell 5,0, debuger programu PowerShell został zaktualizowany do debugowania skryptów, funkcji, poleceń, konfiguracji lub wyrażeń, które są uruchomione w konsoli lub Windows PowerShell ISE na komputerach zdalnych.Starting in PowerShell 5.0, the PowerShell debugger has been updated to debug scripts, functions, commands, configurations, or expressions that are running in either the console or Windows PowerShell ISE on remote computers. Można uruchomić Enter-PSSession polecenie, aby rozpocząć interaktywną sesję zdalnego programu PowerShell, w której można ustawić punkty przerwania i debugowanie plików skryptów oraz poleceń na komputerze zdalnym.You can run Enter-PSSession to start an interactive remote PowerShell session in which you can set breakpoints and debug script files and commands on the remote computer. Enter-PSSession funkcje zostały zaktualizowane, aby umożliwić ponowne nawiązywanie połączenia z usługą i wprowadzanie rozłączonej sesji, na której działa skrypt lub polecenie na komputerze zdalnym.Enter-PSSession functionality has been updated to let you reconnect to and enter a disconnected session that is running a script or command on a remote computer. Jeśli uruchomiony skrypt trafi punkt przerwania, sesja klienta automatycznie uruchamia debuger.If the running script hits a breakpoint, your client session automatically starts the debugger. Jeśli sesja rozłączona z uruchomionym skryptem już osiągnęła punkt przerwania i jest zatrzymana w punkcie przerwania, program Enter-PSSession automatycznie uruchamia debuger wiersza polecenia po ponownym nawiązaniu połączenia z sesją.If the disconnected session that is running a script has already hit a breakpoint, and is stopped at the breakpoint, Enter-PSSession automatically starts the command-line debugger, after you reconnect to the session.

Za pomocą funkcji debugera programu PowerShell można przeglądać skrypt, funkcję, polecenie lub wyrażenie programu PowerShell, gdy jest on uruchomiony.You can use the features of the PowerShell debugger to examine a PowerShell script, function, command, or expression while it is running. 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ń.The PowerShell debugger includes a set of cmdlets that let you set breakpoints, manage breakpoints, and view the call stack.

Polecenia cmdlet debugeraDebugger Cmdlets

Debuger programu PowerShell zawiera następujący zestaw poleceń cmdlet:The PowerShell debugger includes the following set of cmdlets:

  • Set-PSBreakpoint: Ustawia punkty przerwania dla linii, zmiennych i poleceń.Set-PSBreakpoint: Sets breakpoints on lines, variables, and commands.
  • Get-PSBreakpoint: Pobiera punkty przerwania w bieżącej sesji.Get-PSBreakpoint: Gets breakpoints in the current session.
  • Disable-PSBreakpoint: Wyłącza punkty przerwania w bieżącej sesji.Disable-PSBreakpoint: Turns off breakpoints in the current session.
  • Enable-PSBreakpoint: Ponowne włączenie punktów przerwania w bieżącej sesji.Enable-PSBreakpoint: Re-enables breakpoints in the current session.
  • Remove-PSBreakpoint: Usuwa punkty przerwania z bieżącej sesji.Remove-PSBreakpoint: Deletes breakpoints from the current session.
  • Get-PSCallStack: Wyświetla bieżący stos wywołań.Get-PSCallStack: Displays the current call stack.

Uruchamianie i zatrzymywanie debugeraStarting and Stopping the Debugger

Aby uruchomić debuger, należy ustawić co najmniej jeden punkt przerwania.To start the debugger, set one or more breakpoints. Następnie uruchom skrypt, polecenie lub funkcję, którą chcesz debugować.Then, run the script, command, or function that you want to debug.

Po osiągnięciu punktu przerwania, wykonanie zostaje zatrzymane i kontrola jest przełączana do debugera.When you reach a breakpoint, execution stops, and control is turned over to the debugger.

Aby zatrzymać debuger, uruchom skrypt, polecenie lub funkcję do momentu jego zakończenia.To stop the debugger, run the script, command, or function until it is complete. Lub wpisz stop lub t .Or, type stop or t.

Polecenia debugeraDebugger Commands

W przypadku używania debugera w konsoli programu PowerShell Użyj następujących poleceń, aby sterować wykonywaniem.When you use the debugger in the PowerShell console, use the following commands to control the execution. W Windows PowerShell ISE Użyj poleceń z menu Debugowanie.In Windows PowerShell ISE, use commands on the Debug menu.

Uwaga: Aby uzyskać informacje dotyczące sposobu korzystania z debugera w innych aplikacjach hosta, zobacz dokumentację aplikacji hosta.Note: For information about how to use the debugger in other host applications, see the host application documentation.

  • s, StepInto : Wykonuje następną instrukcję, a następnie kończy działanie.s, StepInto: Executes the next statement and then stops.

  • v, StepOver : Wykonuje następną instrukcję, ale pomija funkcje i wywołania.v, StepOver: Executes the next statement, but skips functions and invocations. Pominięte instrukcje są wykonywane, ale nie są przełączane przez program.The skipped statements are executed, but not stepped through.

  • Ctrl+Break: (Break All in ISE) dzieli się na uruchomiony skrypt w konsoli programu PowerShell lub Windows PowerShell ISE.Ctrl+Break: (Break All in ISE) Breaks into a running script within either the PowerShell console, or Windows PowerShell ISE. Należy zauważyć Ctrl, że + przerwanie Ctrl w programie Windows PowerShell 2,0, 3,0 i 4,0 zamyka program.Note that Ctrl+Break in Windows PowerShell 2.0, 3.0, and 4.0 closes the program. Przerwij wszystkie działania w lokalnych i zdalnych skryptach interakcyjnych.Break All works on both local and remote interactively-running scripts.

  • o, StepOut : Wykonaj czynności z bieżącej funkcji; o jeden poziom w górę, jeśli jest zagnieżdżony.o, StepOut: Steps out of the current function; up one level if nested. Jeśli w głównej treści, przechodzi do końca lub następnego punktu przerwania.If in the main body, it continues to the end or the next breakpoint. Pominięte instrukcje są wykonywane, ale nie są przełączane przez program.The skipped statements are executed, but not stepped through.

  • c, Continue : Kontynuuje działanie, dopóki skrypt nie zostanie ukończony lub do momentu osiągnięcia następnego punktu przerwania.c, Continue: Continues to run until the script is complete or until the next breakpoint is reached. Pominięte instrukcje są wykonywane, ale nie są przełączane przez program.The skipped statements are executed, but not stepped through.

  • l, List : Wyświetla część skryptu, który jest wykonywany.l, List: Displays the part of the script that is executing. Domyślnie wyświetla bieżący wiersz, pięć poprzednich wierszy i 10 kolejnych wierszy.By default, it displays the current line, five previous lines, and 10 subsequent lines. Aby kontynuować wyświetlanie skryptu, naciśnij klawisz ENTER.To continue listing the script, press ENTER.

  • l <m>, List : Wyświetla 16 wierszy skryptu rozpoczynając od numeru wiersza określonego przez <m> .l <m>, List: Displays 16 lines of the script beginning with the line number specified by <m>.

  • l <m> <n>, List : Wyświetla <n> wiersze skryptu, rozpoczynając od numeru wiersza określonego przez <m> .l <m> <n>, List: Displays <n> lines of the script, beginning with the line number specified by <m>.

  • q, Stop , Exit : Kończy wykonywanie skryptu i zamyka debuger.q, Stop, Exit: Stops executing the script, and exits the debugger. W przypadku debugowania zadania przez uruchomienie Debug-Job polecenia cmdlet polecenie powoduje Exit odłączenie debugera i umożliwia kontynuowanie działania zadania.If you are debugging a job by running the Debug-Job cmdlet, the Exit command detaches the debugger, and allows the job to continue running.

  • k, Get-PsCallStack : Wyświetla bieżący stos wywołań.k, Get-PsCallStack: Displays the current call stack.

  • <Enter>: Powtarza ostatnie polecenie, jeśli zostało ono Stepne, Przekrocz (v) lub list (l).<Enter>: Repeats the last command if it was Step (s), StepOver (v), or List (l). W przeciwnym razie reprezentuje akcję przesyłania.Otherwise, represents a submit action.

  • ?, h : Wyświetla pomoc polecenia debugera.?, h: Displays the debugger command Help.

Aby wyjść z debugera, można użyć Stop (q).To exit the debugger, you can use Stop (q).

Począwszy od programu PowerShell 5,0, można uruchomić polecenie zakończenia, aby zamknąć zagnieżdżoną sesję debugowania uruchomioną przez uruchomienie polecenia Debug-Job lub Debug-Runspace .Starting in PowerShell 5.0, you can run the Exit command to exit a nested debugging session that you started by running either Debug-Job or Debug-Runspace.

Za pomocą tych poleceń debugera można uruchomić skrypt, zatrzymać w punkcie zainteresowania, przejrzeć wartości zmiennych i stanu systemu, a następnie kontynuować uruchamianie skryptu do momentu zidentyfikowania problemu.By using these debugger commands, you can run a script, stop on a point of concern, examine the values of variables and the state of the system, and continue running the script until you have identified a problem.

Uwaga: w przypadku przełączenia instrukcji z operatorem przekierowania, na przykład ">", debuger programu PowerShell przeprowadzi wszystkie pozostałe instrukcje w skrypcie.NOTE: If you step into a statement with a redirection operator, such as ">", the PowerShell debugger steps over all remaining statements in the script.

Wyświetlanie wartości zmiennych skryptuDisplaying the Values of script Variables

W debugerze można także wprowadzać polecenia, wyświetlać wartość zmiennych, używać poleceń cmdlet i uruchamiać skrypty w wierszu polecenia.While you are in the debugger, you can also enter commands, display the value of variables, use cmdlets, and run scripts at the command line.

Można wyświetlić bieżącą wartość wszystkich zmiennych w skrypcie, który jest debugowany, z wyjątkiem następujących zmiennych automatycznych:You can display the current value of all variables in the script that is being debugged, except for the following automatic variables:

$_
$Args
$Input
$MyInvocation
$PSBoundParameters

Jeśli spróbujesz wyświetlić wartość którejkolwiek z tych zmiennych, uzyskasz wartość tej zmiennej dla potoku wewnętrznego, która używa debugera, a nie wartości zmiennej w skrypcie.If you try to display the value of any of these variables, you get the value of that variable for in an internal pipeline the debugger uses, not the value of the variable in the script.

Aby wyświetlić wartość tych zmiennych dla skryptu, który jest debugowany, w skrypcie Przypisz wartość zmiennej automatycznej do nowej zmiennej.To display the value these variables for the script that is being debugged, in the script, assign the value of the automatic variable to a new variable. Następnie można wyświetlić wartość nowej zmiennej.Then you can display the value of the new variable.

Przykład:For example,

$scriptArgs = $Args
$scriptArgs

W przykładzie w tym temacie wartość $MyInvocation zmiennej jest ponownie przypisywana w następujący sposób:In the example in this topic, the value of the $MyInvocation variable is reassigned as follows:

$scriptname = $MyInvocation.MyCommand.Path

Środowisko debugeraThe Debugger Environment

Po osiągnięciu punktu przerwania należy wprowadzić środowisko debugera.When you reach a breakpoint, you enter the debugger environment. Wiersz polecenia zmieni się tak, aby rozpoczynał się od "[DBG]:".The command prompt changes so that it begins with "[DBG]:".

Aby uzyskać więcej informacji na temat dostosowywania monitu, zobacz about_Prompts.For more information about customizing the prompt, see about_Prompts.

Ponadto w niektórych aplikacjach hosta, takich jak konsola programu PowerShell (ale nie w zintegrowanym środowisku skryptów programu Windows PowerShell [ISE]), zagnieżdżony monit zostanie otwarty na potrzeby debugowania.Also, in some host applications, such as the PowerShell console, (but not in Windows PowerShell Integrated Scripting Environment [ISE]), a nested prompt opens for debugging. Możesz wykryć zagnieżdżony monit przez powtarzające się znaki większe niż (ASCII 62), które pojawiają się w wierszu polecenia.You can detect the nested prompt by the repeating greater-than characters (ASCII 62) that appear at the command prompt.

Na przykład następujący kod jest domyślnym monitem debugowania w konsoli programu PowerShell:For example, the following is the default debugging prompt in the PowerShell console:

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

Możesz znaleźć poziom zagnieżdżenia przy użyciu $NestedPromptLevel zmiennej automatycznej.You can find the nesting level by using the $NestedPromptLevel automatic variable.

Ponadto zmienna automatyczna, $PSDebugContext ,, jest zdefiniowana w zakresie lokalnym.Additionally, an automatic variable, $PSDebugContext, is defined in the local scope. Możesz użyć obecności $PsDebugContext zmiennej, aby określić, czy jesteś w debugerze.You can use the presence of the $PsDebugContext variable to determine whether you are in the debugger.

Przykład:For example:

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

Możesz użyć wartości $PSDebugContext zmiennej w debugowaniu.You can use the value of the $PSDebugContext variable in your debugging.

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

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

Debugowanie i zakresDebugging and Scope

Podział na debuger nie zmienia zakresu, w którym pracujesz, ale gdy docierasz do punktu przerwania w skrypcie, przejdziesz do zakresu skryptu.Breaking into the debugger does not change the scope in which you are operating, but when you reach a breakpoint in a script, you move into the script scope. Zakres skryptu jest elementem podrzędnym zakresu, w którym został uruchomiony debuger.The script scope is a child of the scope in which you ran the debugger.

Aby znaleźć zmienne i aliasy, które są zdefiniowane w zakresie skryptu, użyj parametru scope Get-Alias Get-Variable poleceń cmdlet lub.To find the variables and aliases that are defined in the script scope, use the Scope parameter of the Get-Alias or Get-Variable cmdlets.

Na przykład następujące polecenie pobiera zmienne w lokalnym zakresie (skrypt):For example, the following command gets the variables in the local (script) scope:

Get-Variable -scope 0

Można skrócić polecenie jako:You can abbreviate the command as:

gv -s 0

Jest to przydatny sposób, aby zobaczyć tylko zmienne zdefiniowane w skrypcie i zdefiniowane podczas debugowania.This is a useful way to see only the variables that you defined in the script and that you defined while debugging.

Debugowanie w wierszu poleceniaDebugging at the Command Line

Po ustawieniu zmiennej punktu przerwania lub punktu przerwania polecenia można ustawić punkt przerwania tylko w pliku skryptu.When you set a variable breakpoint or a command breakpoint, you can set the breakpoint only in a script file. Jednak punkt przerwania jest ustawiany domyślnie dla wszystkich elementów, które są uruchamiane w bieżącej sesji.However, by default, the breakpoint is set on anything that runs in the current session.

Na przykład, jeśli ustawisz punkt przerwania dla $name zmiennej, debuger przerwie się w dowolnej $name zmiennej w dowolnym skrypcie, polecenie, funkcja, polecenie cmdlet lub wyrażenie uruchamiane do momentu wyłączenia lub usunięcia punktu przerwania.For example, if you set a breakpoint on the $name variable, the debugger breaks on any $name variable in any script, command, function, script cmdlet or expression that you run until you disable or remove the breakpoint.

Pozwala to debugować skrypty w bardziej realistycznym kontekście, w którym mogą mieć wpływ funkcje, zmienne i inne skrypty w sesji oraz w profilu użytkownika.This allows you to debug your scripts in a more realistic context in which they might be affected by functions, variables, and other scripts in the session and in the user's profile.

Punkty przerwania wierszy są specyficzne dla plików skryptów, więc są ustawiane tylko w plikach skryptów.Line breakpoints are specific to script files, so they are set only in script files.

Funkcje debugowaniaDebugging Functions

Po ustawieniu punktu przerwania w funkcji, która ma Begin Process sekcje, i, End debuger przerywa się w pierwszym wierszu każdej sekcji.When you set a breakpoint on a function that has Begin, Process, and End sections, the debugger breaks at the first line of each section.

Przykład:For example:

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 zdalnychDebugging Remote Scripts

Począwszy od programu PowerShell 5,0, można uruchomić debuger programu PowerShell w sesji zdalnej, w konsoli programu lub Windows PowerShell ISE.Starting in PowerShell 5.0, you can run the PowerShell debugger in a remote session, in either the console, or Windows PowerShell ISE. Enter-PSSession funkcja została zaktualizowana w celu umożliwienia ponownego nawiązania połączenia z usługą i wprowadzenia rozłączonej sesji, która jest uruchomiona na komputerze zdalnym, i aktualnie uruchomionego skryptu.Enter-PSSession functionality has been updated to let you reconnect to and enter a disconnected session that is running on a remote computer, and currently running a script. Jeśli uruchomiony skrypt trafi punkt przerwania, sesja klienta automatycznie uruchamia debuger.If the running script hits a breakpoint, your client session automatically starts the debugger.

Poniżej przedstawiono przykład pokazujący, jak to działa, przy użyciu punktów przerwania ustawionych w skrypcie w wierszach 6, 11, 22 i 25.The following is an example that shows how this works, with breakpoints set in a script at lines 6, 11, 22, and 25. Należy zauważyć, że w przykładzie, gdy zostanie uruchomiony debuger, istnieją dwa monity identyfikujące: Nazwa komputera, na którym jest uruchomiona sesja, oraz monit, który umożliwia sprawdzenie, czy jesteś w trybie debugowania.Note that in the example, when the debugger starts, there are two identifying prompts: the name of the computer on which the session is running, and the DBG prompt that lets you know you are in debugging mode.

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ładyExamples

Ten skrypt testowy wykrywa wersję systemu operacyjnego i wyświetla odpowiedni komunikat systemowy.This test script detects the version of the operating system and displays a system-appropriate message. Zawiera funkcję, wywołanie funkcji i zmienną.It includes a function, a function call, and a variable.

Następujące polecenie wyświetla zawartość pliku skryptu testowego:The following command displays the contents of the test script file:

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ąć, należy ustawić punkt przerwania w punkcie zainteresowania skryptu, taki jak wiersz, polecenie, zmienna lub funkcja.To start, set a breakpoint at a point of interest in the script, such as a line, command, variable, or function.

Zacznij od utworzenia punktu przerwania linii w pierwszym wierszu skryptu Test.ps1 w bieżącym katalogu.Start by creating a line breakpoint on the first line of the Test.ps1 script in the current directory.

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

Można skrócić to polecenie jako:You can abbreviate this command as:

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

Polecenie zwraca obiekt punktu przerwania wiersza ( System. Management. Automation. LineBreakpoint ).The command returns a line-breakpoint object ( 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.Now, start the script.

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

Gdy skrypt osiągnie pierwszy punkt przerwania, komunikat punktu przerwania wskazuje, że debuger jest aktywny.When the script reaches the first breakpoint, the breakpoint message indicates that the debugger is active. Opisuje punkt przerwania i przegląda pierwszy wiersz skryptu, który jest deklaracją funkcji.It describes the breakpoint and previews the first line of the script, which is a function declaration. Wiersz polecenia zmieni się również w celu wskazania, że debuger ma kontrolę.The command prompt also changes to indicate that the debugger has control.

Wiersz podglądu zawiera nazwę skryptu i numer wiersza polecenia z podglądem.The preview line includes the script name and the line number of the previewed command.

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 poleceń kroku, aby wykonać pierwszą instrukcję w skrypcie i wyświetlić podgląd następnej instrukcji.Use the Step command (s) to execute the first statement in the script and to preview the next statement. Następna instrukcja używa $MyInvocation zmiennej automatycznej, aby ustawić wartość $scriptName zmiennej na ścieżkę i nazwę pliku skryptu.The next statement uses the $MyInvocation automatic variable to set the value of the $scriptName variable to the path and file name of the script file.

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

W tym momencie $scriptName zmienna nie jest wypełniona, ale można sprawdzić wartość zmiennej, wyświetlając jej wartość.At this point, the $scriptName variable is not populated, but you can verify the value of the variable by displaying its value. W tym przypadku wartość jest $null .In this case, the value is $null.

DBG> $scriptname
# DBG>

Użyj innych poleceń kroku, aby wykonać bieżącą instrukcję i wyświetlić podgląd następnej instrukcji w skrypcie.Use another Step command (s) to execute the current statement and to preview the next statement in the script. Następna instrukcja wywołuje funkcję PsVersion.The next statement calls the PsVersion function.

DBG> s
test.ps1:12  psversion

W tym momencie $scriptName zmienna jest wypełniana, ale można sprawdzić wartość zmiennej przez wyświetlenie jej wartości.At this point, the $scriptName variable is populated, but you verify the value of the variable by displaying its value. W takim przypadku wartość jest ustawiana na ścieżkę skryptu.In this case, the value is set to the script path.

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

Użyj innego polecenia krok, aby wykonać wywołanie funkcji.Use another Step command to execute the function call. Naciśnij klawisz ENTER lub wpisz "s", aby przejść do kroku.Press ENTER, or type "s" for Step.

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

Komunikat debugowania zawiera podgląd instrukcji w funkcji.The debug message includes a preview of the statement in the function. Aby wykonać tę instrukcję i wyświetlić podgląd następnej instrukcji w funkcji, można użyć Step polecenia.To execute this statement and to preview the next statement in the function, you can use a Step command. Ale w tym przypadku należy użyć polecenia Stepout — (o).But, in this case, use a StepOut command (o). Kończy wykonywanie funkcji (chyba że osiągnie punkt przerwania) i kroki do następnej instrukcji w skrypcie.It completes the execution of the function (unless it reaches a breakpoint) and steps to the next statement in the script.

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

Ponieważ znajdujemy się na ostatniej instrukcji w skrypcie, polecenia Step, Stepout — i Continue mają ten sam efekt.Because we are on the last statement in the script, the Step, StepOut, and Continue commands have the same effect. W takim przypadku należy użyć Stepout — (o).In this case, use StepOut (o).

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

Polecenie Stepout — wykonuje ostatnie polecenie.The StepOut command executes the last command. Standardowy wiersz polecenia wskazuje, że debuger zakończył działanie i zwraca kontrolę do procesora poleceń.The standard command prompt indicates that the debugger has exited and returned control to the command processor.

Teraz ponownie uruchom debuger.Now, run the debugger again. Najpierw, aby usunąć bieżący punkt przerwania, użyj Get-PsBreakpoint Remove-PsBreakpoint poleceń cmdlet i.First, to delete the current breakpoint, use the Get-PsBreakpoint and Remove-PsBreakpoint cmdlets. (Jeśli sądzisz, że możesz ponownie użyć punktu przerwania, użyj Disable-PsBreakpoint polecenia cmdlet zamiast Remove-PsBreakpoint .)(If you think you might reuse the breakpoint, use the Disable-PsBreakpoint cmdlet instead of Remove-PsBreakpoint.)

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

Można skrócić to polecenie jako:You can abbreviate this command as:

PS C:\ps-test> gbp | rbp

Lub uruchom polecenie, pisząc funkcję, taką jak następująca funkcja:Or, run the command by writing a function, such as the following function:

function delbr { gbp | rbp }

Teraz Utwórz punkt przerwania dla $scriptname zmiennej.Now, create a breakpoint on the $scriptname variable.

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

Można skrócić polecenie jako:You can abbreviate the command as:

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

Teraz uruchom skrypt.Now, start the script. Skrypt osiągnie zmienny punkt przerwania.The script reaches the variable breakpoint. Domyślnym trybem jest Write, dlatego wykonywanie kończy się tuż przed instrukcją, która zmienia wartość zmiennej.The default mode is Write, so execution stops just before the statement that changes the value of the variable.

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świetla bieżącą wartość $scriptName zmiennej, czyli $null .Display the current value of the $scriptName variable, which is $null.

DBG> $scriptName
# DBG>

Użyj poleceń kroku, aby wykonać instrukcję, która wypełnia zmienną.Use a Step command (s) to execute the statement that populates the variable. Następnie Wyświetl nową wartość $scriptName zmiennej.Then, display the new value of the $scriptName variable.

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ępną instrukcją jest wywołanie funkcji PsVersion.The next statement is a call to the PsVersion function. Aby pominąć funkcję, ale nadal ją wykonuje, użyj polecenia Przekrocz (v).To skip the function but still execute it, use a StepOver command (v). Jeśli funkcja Przekrocz jest już używana, nie jest skuteczna.If you are already in the function when you use StepOver, it is not effective. Wywołanie funkcji jest wyświetlane, ale nie jest wykonywane.The function call is displayed, but it is not executed.

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

Polecenie Przekrocz wykonuje funkcję i przegląda następną instrukcję w skrypcie, która drukuje ostatni wiersz.The StepOver command executes the function, and it previews the next statement in the script, which prints the final line.

Użyj polecenia zatrzymania (t), aby zamknąć debuger.Use a Stop command (t) to exit the debugger. Wiersz polecenia wraca do standardowego wiersza polecenia.The command prompt reverts to the standard command prompt.

C:\ps-test>

Aby usunąć punkty przerwania, użyj Get-PsBreakpoint Remove-PsBreakpoint poleceń cmdlet i.To delete the breakpoints, use the Get-PsBreakpoint and Remove-PsBreakpoint cmdlets.

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

Utwórz nowy punkt przerwania polecenia w funkcji PsVersion.Create a new command breakpoint on the PsVersion function.

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

Można skrócić to polecenie do:You can abbreviate this command to:

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

Teraz uruchom skrypt.Now, run the script.

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.The script reaches the breakpoint at the function call. W tym momencie funkcja nie została jeszcze wywołana.At this point, the function has not yet been called. Dzięki temu można użyć parametru akcji w Set-PSBreakpoint celu ustawienia warunków wykonywania punktu przerwania lub wykonywania zadań przygotowawczych lub diagnostycznych, takich jak uruchamianie dziennika lub Wywoływanie skryptu diagnostyki lub zabezpieczeń.This gives you the opportunity to use the Action parameter of Set-PSBreakpoint to set conditions for the execution of the breakpoint or to perform preparatory or diagnostic tasks, such as starting a log or invoking a diagnostic or security script.

Aby ustawić akcję, użyj polecenia Kontynuuj (c), aby zamknąć skrypt, i Remove-PsBreakpoint polecenie usunięcia bieżącego punktu przerwania.To set an action, use a Continue command (c) to exit the script, and a Remove-PsBreakpoint command to delete the current breakpoint. (Punkty przerwania są tylko do odczytu, więc nie można dodać akcji do bieżącego punktu przerwania).(Breakpoints are read-only, so you cannot add an action to the current breakpoint.)

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ą.Now, create a new command breakpoint with an action. Następujące polecenie ustawia punkt przerwania polecenia z akcją, która rejestruje wartość zmiennej, $scriptName gdy wywoływana jest funkcja.The following command sets a command breakpoint with an action that logs the value of the $scriptName variable when the function is called. Ponieważ słowo kluczowe Break nie jest używane w akcji, wykonywanie nie zostanie zatrzymane.Because the Break keyword is not used in the action, execution does not stop. (") Jest znakiem kontynuacji wiersza.)(The backtick (`) is the line-continuation character.)

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 dla punktu przerwania.You can also add actions that set conditions for the breakpoint. W poniższym poleceniu punkt przerwania polecenia jest wykonywany tylko wtedy, gdy zasady wykonywania są ustawione na RemoteSigned, najbardziej restrykcyjnymi zasadami, które nadal pozwalają na uruchamianie skryptów.In the following command, the command breakpoint is executed only if the execution policy is set to RemoteSigned, the most restrictive policy that still permits you to run scripts. (") Jest znakiem kontynuacji.(The backtick (`) is the continuation character.)

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.The Break keyword in the action directs the debugger to execute the breakpoint. Możesz również użyć słowa kluczowego continue, aby skierować debuger do wykonywania bez przerywania.You can also use the Continue keyword to direct the debugger to execute without breaking. Ponieważ słowo kluczowe default jest kontynuowane, należy określić przerwanie, aby zatrzymać wykonywanie.Because the default keyword is Continue, you must specify Break to stop execution.

Teraz uruchom skrypt.Now, run the script.

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 , wykonywanie jest przerywane przy wywołaniu funkcji.Because the execution policy is set to RemoteSigned , execution stops at the function call.

W tym momencie warto sprawdzić stos wywołań.At this point, you might want to check the call stack. Użyj polecenia Get-PsCallStack cmdlet lub Get-PsCallStack debugera (k).Use the Get-PsCallStack cmdlet or the Get-PsCallStack debugger command (k). Następujące polecenie pobiera bieżący stos wywołań.The following command gets the current call stack.

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

Ten przykład pokazuje zaledwie kilka sposobów na korzystanie z debugera programu PowerShell.This example demonstrates just a few of the many ways to use the PowerShell debugger.

Aby uzyskać więcej informacji na temat poleceń cmdlet debugera, wpisz następujące polecenie:For more information about the debugger cmdlets, type the following command:

help <cmdlet-name> -full

Na przykład wpisz:For example, type:

help Set-PSBreakpoint -full

Inne funkcje debugowania w programie PowerShellOther Debugging Features in PowerShell

Oprócz debugera programu PowerShell program PowerShell zawiera kilka innych funkcji, których można użyć do debugowania skryptów i funkcji.In addition to the PowerShell debugger, PowerShell includes several other features that you can use to debug scripts and functions.

  • Windows PowerShell ISE zawiera interaktywny debuger graficzny.Windows PowerShell ISE includes an interactive graphical debugger. Aby uzyskać więcej informacji, Uruchom Windows PowerShell ISE i naciśnij klawisz F1.For more information, start Windows PowerShell ISE and press F1.

  • Set-PSDebugPolecenie cmdlet oferuje bardzo podstawowe funkcje debugowania skryptów, w tym krokowe i śledzone.The Set-PSDebug cmdlet offers very basic script debugging features, including stepping and tracing.

  • Użyj Set-StrictMode polecenia cmdlet, aby wykryć odwołania do niezainicjowanych zmiennych, do odwołań do nieistniejących właściwości obiektu i składni funkcji, która jest nieprawidłowa.Use the Set-StrictMode cmdlet to detect references to uninitialized variables, to references to non-existent properties of an object, and to function syntax that is not valid.

  • Dodawanie instrukcji diagnostycznych do skryptu, takich jak instrukcje wyświetlające wartość zmiennych, instrukcje odczytujące dane wejściowe z wiersza polecenia lub instrukcje, które raportują bieżącą instrukcję.Add diagnostic statements to a script, such as statements that display the value of variables, statements that read input from the command line, or statements that report the current instruction. Użyj poleceń cmdlet, które zawierają zlecenie zapisu dla tego zadania, takie jak Write-Host ,, Write-Debug Write-Warning i Write-Verbose .Use the cmdlets that contain the Write verb for this task, such as Write-Host, Write-Debug, Write-Warning, and Write-Verbose.

ZOBACZ RÓWNIEŻSEE ALSO