Freigeben über

about_Debuggers

  • Artikel

Kurze Beschreibung

Beschreibt den PowerShell-Debugger.

Lange Beschreibung

Das Debuggen ist der Prozess der Untersuchung eines Skripts, während es ausgeführt wird, um Fehler in den Skriptanweisungen zu identifizieren und zu beheben. Der PowerShell-Debugger kann Ihnen helfen, Fehler und Ineffizienzen in Ihren Skripts, Funktionen, Befehlen, Konfigurationen der gewünschten PowerShell-Zustandskonfiguration (PowerShell Desired State Configuration, DSC) oder Ausdrücken zu untersuchen und zu identifizieren.

Ab PowerShell 5.0 wurde der PowerShell-Debugger aktualisiert, um Skripts, Funktionen, Befehle, Konfigurationen oder Ausdrücke zu debuggen, die entweder in der Konsole oder in windows PowerShell Integrated Scripting Environment (ISE) auf Remotecomputern ausgeführt werden.

Hinweis

Windows PowerShell ISE unterstützt nur Windows PowerShell. Für PowerShell 6 und höher müssen Sie Visual Studio Code mit der Erweiterung für PowerShell verwenden. Weitere Informationen finden Sie unter Debuggen mit Visual Studio Code.

Debugger-Cmdlets

Der PowerShell-Debugger enthält die folgenden Cmdlets:

  • Set-PSBreakpoint: Legt Haltepunkte für Linien, Variablen und Befehle fest.
  • Get-PSBreakpoint: Ruft Haltepunkte in der aktuellen Sitzung ab.
  • Disable-PSBreakpoint: Deaktiviert Haltepunkte in der aktuellen Sitzung.
  • Enable-PSBreakpoint: Aktiviert Haltepunkte in der aktuellen Sitzung erneut.
  • Remove-PSBreakpoint: Löscht Haltepunkte aus der aktuellen Sitzung.
  • Get-PSCallStack: Zeigt den aktuellen Aufrufstapel an.

Starten und Beenden des Debuggers

Um den Debugger zu starten, legen Sie einen oder mehrere Haltepunkte fest, und führen Sie dann das Skript, den Befehl oder die Funktion aus, die Sie debuggen möchten.

Wenn Sie einen Haltepunkt erreichen, wird die Ausführung beendet und die Steuerung an den Debugger übergeben.

Um den Debugger zu beenden, führen Sie das Skript, den Befehl oder die Funktion aus, bis er abgeschlossen ist. Oder geben stop Sie ein oder aus t.

Debuggerbefehle

Wenn Sie den Debugger in der PowerShell-Konsole verwenden, verwenden Sie die folgenden Befehle, um die Ausführung zu steuern. Verwenden Sie in Windows PowerShell ISE Befehle im Menü "Debuggen".

Hinweis

Informationen zur Verwendung des Debuggers in anderen Hostanwendungen finden Sie in der Dokumentation zur Hostanwendung.

  • s, StepInto: Führt die nächste Anweisung aus und stoppt dann.

  • v, StepOver: Führt die nächste Anweisung aus, überspringt jedoch Funktionen und Aufrufe. Die übersprungenen Anweisungen werden ausgeführt, aber nicht in Einzelschritten durchlaufen.

  • Ctrl+Break: (Alle in ISE unterbrechen) bricht in ein ausgeführtes Skript in der PowerShell-Konsole oder windows PowerShell ISE auf. Beachten Sie, dass strg+Break in Windows PowerShell 2.0, 3.0 und 4.0 das Programm schließt. "Alle unterbrechen" funktioniert sowohl auf lokalen als auch auf Remote-Skripts, die interaktiv ausgeführt werden.

  • o, : StepOutSchritte aus der aktuellen Funktion; eine Ebene nach oben, wenn geschachtelt. Wenn sich der Haupttext befindet, wird er bis zum Ende oder zum nächsten Haltepunkt fortgesetzt. Die übersprungenen Anweisungen werden ausgeführt, aber nicht in Einzelschritten durchlaufen.

  • c, : ContinueWird weiterhin ausgeführt, bis das Skript abgeschlossen ist oder bis der nächste Haltepunkt erreicht ist. Die übersprungenen Anweisungen werden ausgeführt, aber nicht in Einzelschritten durchlaufen.

  • l, List: Zeigt den Teil des ausgeführten Skripts an. Standardmäßig werden die aktuelle Zeile, fünf vorherige Zeilen und 10 nachfolgende Zeilen angezeigt. Um mit der Auflistung des Skripts fortzufahren, drücken Sie die EINGABETASTE.

  • l <m>, List: Zeigt 16 Zeilen des Skripts an, die mit der Zeilennummer beginnen, die durch <m>.

  • l <m> <n>, List: Zeigt <n> Zeilen des Skripts an, beginnend mit der Zeilennummer, die durch <m>.

  • q, , : StopExitBeendet die Ausführung des Skripts und beendet den Debugger. Wenn Sie einen Auftrag debuggen, indem Sie das Debug-Job Cmdlet ausführen, trennt der Befehl den Exit Debugger und ermöglicht es dem Auftrag, die Ausführung fortzusetzen.

  • k, Get-PsCallStack: Zeigt den aktuellen Aufrufstapel an.

  • <Enter>: Wiederholt den letzten Befehl, wenn er Step (s), StepOver (v) oder List (l). Andernfalls stellt eine Sendeaktion dar.

  • ?, h: Zeigt die Hilfe zum Debuggerbefehl an.

Zum Beenden des Debuggers können Sie (q) verwenden Stop .

Ab PowerShell 5.0 können Sie den Befehl "Beenden" ausführen, um eine geschachtelte Debugsitzung zu beenden, die Sie gestartet haben, indem Sie entweder Debug-Job oder Debug-Runspace.

Mithilfe dieser Debuggerbefehle können Sie ein Skript ausführen, an einem bestimmten Punkt anhalten, die Werte von Variablen und den Status des Systems untersuchen und das Skript weiter ausführen, bis Sie ein Problem erkannt haben.

Hinweis

Wenn Sie eine Anweisung mit einem Umleitungsoperator ausführen, z >. B. den PowerShell-Debugger, führt sie alle verbleibenden Anweisungen im Skript durch.

Anzeigen der Werte von Skriptvariablen

Während Sie sich im Debugger befinden, können Sie auch Befehle eingeben, den Wert von Variablen anzeigen, Cmdlets verwenden und Skripts an der Befehlszeile ausführen. Sie können den aktuellen Wert aller Variablen im Skript anzeigen, das gedebuggt wird, mit Ausnahme der folgenden automatischen Variablen:

$_
$Args
$Input
$MyInvocation
$PSBoundParameters

Wenn Sie den Wert einer dieser Variablen anzeigen, erhalten Sie den Wert dieser Variablen für eine interne Pipeline, die der Debugger verwendet, nicht den Wert der Variablen im Skript.

Um den Wert dieser Variablen für das skript anzuzeigen, das gedebuggt wird, fügen Sie Ihrem Skript Zeilen hinzu, um diese Werte in einer neuen Variablen zu speichern. Legen Sie ihren Haltepunkt nach diesen neuen Zeilen fest. Anschließend können Sie den Wert der neuen Variablen anzeigen.

Beispiel: 

$scriptArgs = $Args
$scriptname = $MyInvocation.PSCommandPath

Die Debuggerumgebung

Wenn Sie einen Haltepunkt erreichen, geben Sie die Debuggerumgebung ein. Die Eingabeaufforderung ändert sich so, dass sie mit "[DBG]:"beginnt. Außerdem wird in einigen Hostanwendungen, z. B. der PowerShell-Konsole, eine geschachtelte Eingabeaufforderung zum Debuggen geöffnet. Sie können die geschachtelte Eingabeaufforderung erkennen, indem Sie die wiederholten größer als Zeichen (ASCII 62) erkennen, die an der Eingabeaufforderung angezeigt werden.

Weitere Informationen zum Anpassen der Eingabeaufforderung finden Sie unter about_Prompts.

Sie finden die Schachtelungsebene mithilfe der $NestedPromptLevel automatischen Variablen. Die automatische Variable , $PSDebugContextwird im lokalen Bereich definiert. Sie können das Vorhandensein der $PSDebugContext Variablen verwenden, um zu bestimmen, ob Sie innerhalb des Debuggers ausgeführt werden.

Zum Beispiel:

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

Sie können den Wert der $PSDebugContext Variablen im Debugging verwenden.

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

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

Debuggen und Bereich

Wenn Sie in den Debugger wechseln, ändert sich nicht der Bereich, in dem Sie arbeiten, aber wenn Sie einen Haltepunkt in einem Skript erreichen, wechseln Sie in den Skriptbereich. Der Skriptbereich ist ein untergeordnetes Element des Bereichs, in dem Sie den Debugger ausgeführt haben.

Um die Variablen und Aliase zu finden, die im Skriptbereich definiert sind, verwenden Sie den Scope-Parameter der Get-Alias Oder Get-Variable Cmdlets.

Beispielsweise ruft der folgende Befehl die Variablen im lokalen Bereich (Skript) ab:

Get-Variable -scope 0

Dies ist eine nützliche Möglichkeit, nur die Variablen anzuzeigen, die Sie im Skript definiert haben und die Sie beim Debuggen definiert haben.

Debuggen an der Befehlszeile

Wenn Sie einen variablen Haltepunkt oder einen Befehlshaltepunkt festlegen, können Sie den Haltepunkt nur in einer Skriptdatei festlegen. Standardmäßig ist der Haltepunkt jedoch für alle Elemente festgelegt, die in der aktuellen Sitzung ausgeführt werden.

Wenn Sie z. B. einen Haltepunkt für die $name Variable festlegen, wird der Debugger für jede Variable $name in allen Skripts, Befehlen, Funktionen, Skript-Cmdlets oder Ausdrücken unterbrochen, die Sie ausführen, bis Sie den Haltepunkt deaktivieren oder entfernen.

Auf diese Weise können Sie Ihre Skripts in einem realistischeren Kontext debuggen, in dem sie möglicherweise von Funktionen, Variablen und anderen Skripts in der Sitzung und im Benutzerprofil betroffen sind.

Zeilenumbruchpunkte sind spezifisch für Skriptdateien, sodass sie nur in Skriptdateien festgelegt werden.

Debuggen von Funktionen

Wenn Sie einen Haltepunkt für eine Funktion festlegen, die Abschnitte processenthältbeginend, wird der Debugger an der ersten Zeile jedes Abschnitts umgebrochen.

Zum Beispiel:

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>

Debuggen von Remoteskripts

Sie können ausführen Enter-PSSession , um eine interaktive PowerShell-Remotesitzung zu starten, in der Sie Haltepunkte festlegen und Skriptdateien und Befehle auf dem Remotecomputer debuggen können. Enter-PSSession ermöglicht es Ihnen, eine getrennte Sitzung, die ein Skript oder einen Befehl auf einem Remotecomputer ausführt, erneut zu verbinden. Wenn das ausgeführte Skript auf einen Haltepunkt trifft, startet Ihre Clientsitzung automatisch den Debugger. Wenn die getrennte Sitzung, die ein Skript ausführt, bereits einen Haltepunkt erreicht hat, Enter-PSSession startet der Befehlszeilendebugger automatisch, wenn Sie die Verbindung mit der Sitzung erneut herstellen.

Das folgende Beispiel zeigt, wie dies funktioniert. Haltepunkte wurden in den Zeilen 6, 11, 22 und 25 des Skripts festgelegt. Wenn der Debugger gestartet wird, gibt es zwei identifizierende Änderungen an der Eingabeaufforderung:

  • Der Name des Computers, auf dem die Sitzung ausgeführt wird
  • Die DBG-Eingabeaufforderung, mit der Sie wissen, dass Sie sich im Debugmodus befinden
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>

Beispiele

Dieses Testskript erkennt die Version von PowerShell und zeigt eine versionsgerechte Meldung an. Sie enthält eine Funktion, einen Funktionsaufruf und eine Variable.

Der folgende Befehl zeigt den Inhalt der Testskriptdatei an:

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

Um zu beginnen, legen Sie einen Haltepunkt an einem interessanten Punkt für das Skript fest, z. B. eine Zeile, einen Befehl, eine Variable oder eine Funktion.

Erstellen Sie zunächst einen Zeilenumbruchpunkt in der ersten Zeile des Skripts "Test.ps1" im aktuellen Verzeichnis.

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

Der Befehl gibt ein System.Management.Automation.LineBreakpoint-Objekt zurück.

Column     : 0
Line       : 1
Action     :
Enabled    : True
HitCount   : 0
Id         : 0
Script     : C:\ps-test\test.ps1
ScriptName : C:\ps-test\test.ps1

Starten Sie nun das Skript.

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

Wenn das Skript den ersten Haltepunkt erreicht, gibt die Haltepunktmeldung an, dass der Debugger aktiv ist. Er beschreibt den Haltepunkt und zeigt eine Vorschau der ersten Zeile des Skripts an, bei der es sich um eine Funktionsdeklaration handelt. Die Eingabeaufforderung ändert sich auch, um anzugeben, dass der Debugger über Kontrolle verfügt.

Die Vorschauzeile enthält den Skriptnamen und die Zeilennummer des vorschauierten Befehls.

Entering debug mode. Use h or ? for help.

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

test.ps1:1   function psversion {
DBG>

Verwenden Sie den Befehl "Schritt" (s), um die erste Anweisung im Skript auszuführen und eine Vorschau der nächsten Anweisung anzuzeigen. Die nächste Anweisung verwendet die $MyInvocation automatische Variable, um den Wert der $scriptName Variablen auf den Pfad und Dateinamen der Skriptdatei festzulegen.

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

An diesem Punkt wird die $scriptName Variable nicht aufgefüllt, aber Sie können den Wert der Variablen überprüfen, indem Sie dessen Wert anzeigen. In diesem Fall handelt es sich um den Wert $null.

DBG> $scriptname
DBG>

Verwenden Sie einen anderen Step Befehl (s), um die aktuelle Anweisung auszuführen und eine Vorschau der nächsten Anweisung im Skript anzuzeigen. Die nächste Anweisung ruft die psversion Funktion auf.

DBG> s
test.ps1:12  psversion

An diesem Punkt wird die $scriptName Variable aufgefüllt, aber Sie überprüfen den Wert der Variablen, indem Sie dessen Wert anzeigen. In diesem Fall wird der Wert auf den Skriptpfad festgelegt.

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

Verwenden Sie einen anderen Schritt-Befehl, um den Funktionsaufruf auszuführen. Drücken Sie die EINGABETASTE, oder geben Sie "s" für Schritt ein.

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

Die Debugnachricht enthält eine Vorschau der Anweisung in der Funktion. Um diese Anweisung auszuführen und eine Vorschau der nächsten Anweisung in der Funktion anzuzeigen, können Sie einen Step Befehl verwenden. Verwenden Sie in diesem Fall jedoch einen StepOut-Befehl (o). Sie schließt die Ausführung der Funktion ab (es sei denn, sie erreicht einen Haltepunkt) und die Schritte zur nächsten Anweisung im Skript.

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

Da wir die letzte Anweisung im Skript verwenden, haben die Befehle "Step", "StepOut" und "Continue" den gleichen Effekt. Verwenden Sie in diesem Fall StepOut (o).

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

Der Befehl "StepOut" führt den letzten Befehl aus. Die Standard-Eingabeaufforderung gibt an, dass der Debugger das Steuerelement beendet und an den Befehlsprozessor zurückgegeben hat.

Führen Sie nun den Debugger erneut aus. Zum Löschen des aktuellen Haltepunkts verwenden Sie zunächst die Get-PsBreakpoint Und-Cmdlets Remove-PsBreakpoint . (Wenn Sie denken, dass Sie den Haltepunkt möglicherweise wiederverwenden, verwenden Sie das Disable-PsBreakpoint Cmdlet anstelle von Remove-PsBreakpoint.)

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

Sie können diesen Befehl wie folgt abkürzen:

PS C:\ps-test> gbp | rbp

Oder führen Sie den Befehl aus, indem Sie eine Funktion schreiben, z. B. die folgende Funktion:

function delbr { gbp | rbp }

Erstellen Sie nun einen Haltepunkt für die $scriptname Variable.

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

Sie können den Befehl abkürten als:

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

Starten Sie nun das Skript. Das Skript erreicht den variablen Haltepunkt. Der Standardmodus ist "Schreiben", sodass die Ausführung unmittelbar vor der Anweisung beendet wird, die den Wert der Variablen ändert.

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>

Zeigt den aktuellen Wert der $scriptName Variablen an, also $null.

DBG> $scriptName
DBG>

Verwenden Sie einen Step Befehl (s), um die Anweisung auszuführen, die die Variable auffüllt. Zeigen Sie dann den neuen Wert der $scriptName Variablen an.

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

Verwenden Sie einen Schrittbefehl (s), um eine Vorschau der nächsten Anweisung im Skript anzuzeigen.

DBG> s
test.ps1:12  psversion

Die nächste Anweisung ist ein Aufruf der psversion Funktion. Um die Funktion zu überspringen, aber trotzdem auszuführen, verwenden Sie einen StepOver Befehl (v). Wenn Sie sich bereits in der Funktion befinden, wenn Sie sie verwenden StepOver, ist sie nicht effektiv. Der Funktionsaufruf wird angezeigt, wird jedoch nicht ausgeführt.

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

Der StepOver Befehl führt die Funktion aus, und es wird eine Vorschau der nächsten Anweisung im Skript angezeigt, die die letzte Zeile druckt.

Verwenden Sie einen Stop Befehl (t), um den Debugger zu beenden. Die Eingabeaufforderung wird auf die Standard-Eingabeaufforderung zurückgesetzt.

C:\ps-test>

Verwenden Sie Get-PsBreakpoint die Und-Cmdlets Remove-PsBreakpoint , um die Haltepunkte zu löschen.

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

Erstellen Sie einen neuen Befehlstrennpunkt für die psversion Funktion.

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

Sie können diesen Befehl abkürden wie folgt:

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

Führen Sie nun das Skript aus.

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

test.ps1:12  psversion
DBG>

Das Skript erreicht den Haltepunkt beim Funktionsaufruf. An diesem Punkt wurde die Funktion noch nicht aufgerufen. Auf diese Weise können Sie den Aktionsparameter Set-PSBreakpoint verwenden, um Bedingungen für die Ausführung des Haltepunkts festzulegen oder vorbereitende oder Diagnoseaufgaben auszuführen, z. B. das Starten eines Protokolls oder das Aufrufen eines Diagnose- oder Sicherheitsskripts.

Verwenden Sie zum Festlegen einer Aktion einen Befehl "Weiter" (c), um das Skript zu beenden, und einen Remove-PsBreakpoint Befehl, um den aktuellen Haltepunkt zu löschen. (Haltepunkte sind schreibgeschützt, sodass Sie dem aktuellen Haltepunkt keine Aktion hinzufügen können.)

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>

Erstellen Sie nun einen neuen Befehlshaltepunkt mit einer Aktion. Der folgende Befehl legt einen Befehlshaltepunkt mit einer Aktion fest, die den Wert der $scriptName Variablen protokolliert, wenn die Funktion aufgerufen wird. Da das break Schlüsselwort in der Aktion nicht verwendet wird, wird die Ausführung nicht beendet. Der Backtick (`) ist das Zeilenfortsetzungszeichen.

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

Sie können auch Aktionen hinzufügen, die Bedingungen für den Haltepunkt festlegen. Im folgenden Befehl wird der Befehlshaltepunkt nur ausgeführt, wenn die Ausführungsrichtlinie auf "RemoteSigned" festgelegt ist, die restriktivste Richtlinie, mit der Sie weiterhin Skripts ausführen können.

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

Das break Schlüsselwort in der Aktion leitet den Debugger an, den Haltepunkt auszuführen. Sie können das continue Schlüsselwort auch verwenden, um den Debugger ohne Unterbrechung auszuführen. Da das Standardschlüsselwort lautet continue, müssen Sie angeben break , um die Ausführung zu beenden.

Führen Sie nun das Skript aus.

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

test.ps1:12  psversion

Da die Ausführungsrichtlinie auf "RemoteSigned" festgelegt ist, wird die Ausführung beim Funktionsaufruf beendet.

An diesem Punkt sollten Sie den Aufrufstapel überprüfen. Verwenden Sie das Get-PsCallStack Cmdlet oder den Get-PsCallStack Debuggerbefehl (k). Der folgende Befehl ruft den aktuellen Aufrufstapel ab.

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

In diesem Beispiel werden nur einige der vielen Möglichkeiten zum Verwenden des PowerShell-Debuggers veranschaulicht.

Weitere Debugfeatures in PowerShell

Zusätzlich zum PowerShell-Debugger enthält PowerShell mehrere weitere Features, die Sie zum Debuggen von Skripts und Funktionen verwenden können.

  • Das Set-PSDebug Cmdlet bietet sehr einfache Skriptdebuggingfeatures, einschließlich Schritt- und Ablaufverfolgung.

  • Verwenden Sie das Set-StrictMode Cmdlet, um Verweise auf nicht initialisierte Variablen, Verweise auf nicht vorhandene Eigenschaften eines Objekts und funktionssyntax zu erkennen, die ungültig ist.

  • Fügen Sie einem Skript Diagnoseanweisungen hinzu, z. B. Anweisungen, die den Wert von Variablen, Anweisungen anzeigen, die Eingaben aus der Befehlszeile lesen, oder Anweisungen, die die aktuelle Anweisung melden. Verwenden Sie die Cmdlets, die das Verb "Write" für diese Aufgabe enthalten, z Write-Host. B. , , Write-Debug, Write-Warningund Write-Verbose.

Siehe auch