about_Debuggers

KORT BESKRIVNING

Beskriver PowerShell-felsökaren.

LÅNG BESKRIVNING

Felsökning är en process för att undersöka ett skript medan det körs för att identifiera och korrigera fel i skriptanvisningarna. PowerShell-felsökaren kan hjälpa dig att undersöka och identifiera fel och ineffektivitet i dina skript, funktioner, kommandon, PowerShell Desired State Configuration-konfigurationer (DSC) eller uttryck.

Från och med PowerShell 5.0 har PowerShell-felsökaren uppdaterats för att felsöka skript, funktioner, kommandon, konfigurationer eller uttryck som körs i antingen -konsolen eller Windows PowerShell ISE på fjärrdatorer. Du kan köra för att starta en interaktiv PowerShell-fjärrsession där du kan ange brytpunkter och felsöka skriptfiler och Enter-PSSession kommandon på fjärrdatorn. Enter-PSSession funktionen har uppdaterats så att du kan återansluta till och ange en frånkopplad session som kör ett skript eller kommando på en fjärrdator. Om skriptet som körs når en brytpunkt startar klientsessionen automatiskt felsökningsprogrammet. Om den frånkopplade sessionen som kör ett skript redan har kommit till en brytpunkt och stoppas vid brytpunkten startar automatiskt felsökningsprogrammet på kommandoraden när du har återanslutt till Enter-PSSession sessionen.

Du kan använda funktionerna i PowerShell-felsökaren för att undersöka ett PowerShell-skript, en funktion, ett kommando eller ett uttryck medan det körs. PowerShell-felsökningsprogrammet innehåller en uppsättning cmdlets som gör att du kan ange brytpunkter, hantera brytpunkter och visa anropsstacken.

Felsöknings-cmdlets

PowerShell-felsökningsprogrammet innehåller följande uppsättning cmdlets:

  • Set-PSBreakpoint: Anger brytpunkter på rader, variabler och kommandon.
  • Get-PSBreakpoint: Hämtar brytpunkter i den aktuella sessionen.
  • Disable-PSBreakpoint: Inaktiverar brytpunkter i den aktuella sessionen.
  • Enable-PSBreakpoint: Återaktivera brytpunkter i den aktuella sessionen.
  • Remove-PSBreakpoint: Tar bort brytpunkter från den aktuella sessionen.
  • Get-PSCallStack: Visar den aktuella anropsstacken.

Starta och stoppa felsökningsprogrammet

Starta felsökningsprogrammet genom att ange en eller flera brytpunkter. Kör sedan skriptet, kommandot eller funktionen som du vill felsöka.

När du når en brytpunkt stoppas körningen och kontrollen omvandlas till felsökningsprogrammet.

Om du vill stoppa felsökningsprogrammet kör du skriptet, kommandot eller funktionen tills det är klart. Eller skriv stop eller t .

Felsökningskommandon

När du använder felsökningsprogrammet i PowerShell-konsolen använder du följande kommandon för att styra körningen. I Windows PowerShell ISE du kommandon på felsökningsmenyn.

Obs! Information om hur du använder felsökningsprogrammet i andra värdprogram finns i dokumentationen för värdprogram.

  • s, StepInto : Kör nästa instruktion och stoppar sedan.

  • v, StepOver : Kör nästa instruktion, men hoppar över funktioner och anrop. De överhoppade isatserna körs, men de stegas inte igenom.

  • Ctrl+Break: (Bryt ned alla i ISE) Delar upp i ett skript som körs i antingen PowerShell-konsolen eller Windows PowerShell ISE. Observera att + Ctrl-Windows PowerShell 2.0, 3.0 och 4.0 stänger programmet. Break All fungerar på både lokala skript och fjärrskript som körs interaktivt.

  • o, StepOut : Steg ut ur den aktuella funktionen, upp en nivå om den är kapslad. Om den finns i huvudtexten fortsätter den till slutet eller nästa brytpunkt. De överhoppade isatserna körs, men de stegvisas inte igenom.

  • c, Continue : Fortsätter att köras tills skriptet har slutförts eller tills nästa brytpunkt har nåtts. De överhoppade isatserna körs, men de stegvisas inte igenom.

  • l, List : Visar den del av skriptet som körs. Som standard visas den aktuella raden, fem föregående rader och 10 efterföljande rader. Tryck på RETUR för att fortsätta lista skriptet.

  • l <m>, List : Visar 16 rader i skriptet som börjar med radnumret som anges av <m> .

  • l <m> <n>, List : Visar rader i skriptet som börjar med <n> radnumret som anges av <m> .

  • q, Stop , : Slutar köra skriptet och avslutar Exit felsökningsprogrammet. Om du felsöker ett jobb genom att köra cmdleten fråntar kommandot felsökningsprogrammet och tillåter Debug-Job att jobbet fortsätter att Exit köras.

  • k, Get-PsCallStack : Visar den aktuella anropsstacken.

  • <Enter>: Upprepar det sista kommandot om det var Step (s), StepOver (v) eller List (l). Annars representerar en skicka-åtgärd.

  • ?, h : Visar felsökningskommandot Hjälp.

Om du vill avsluta felsökningsprogrammet kan du använda Stoppa (q).

Från och med PowerShell 5.0 kan du köra kommandot Avsluta för att avsluta en kapslad felsökningssession som du startade genom att köra Debug-Job antingen eller Debug-Runspace .

Med hjälp av de här felsökningskommandona kan du köra ett skript, stoppa vid en viss tidpunkt, undersöka värdena för variabler och systemets tillstånd och fortsätta att köra skriptet tills du har identifierat ett problem.

Obs! Om du går in i en instruktion med en omdirigeringsoperator, till exempel ">", stegar PowerShell-felsökaren igenom alla återstående instruktioner i skriptet.

Visa värdena för skriptvariabler

När du är i felsökningsprogrammet kan du också ange kommandon, visa värdet för variabler, använda cmdlets och köra skript på kommandoraden.

Du kan visa det aktuella värdet för alla variabler i skriptet som felsöks, förutom följande automatiska variabler:

$_
$Args
$Input
$MyInvocation
$PSBoundParameters

Om du försöker visa värdet för någon av dessa variabler får du värdet för variabeln för i en intern pipeline som felsökningsprogrammet använder, inte värdet för variabeln i skriptet.

Om du vill visa värdet för dessa variabler för skriptet som felsöks tilldelar du i skriptet värdet för den automatiska variabeln till en ny variabel. Sedan kan du visa värdet för den nya variabeln.

Exempel:

$scriptArgs = $Args
$scriptArgs

I exemplet i det här avsnittet omtilldelades värdet för $MyInvocation variabeln på följande sätt:

$scriptname = $MyInvocation.MyCommand.Path

Felsökningsmiljön

När du når en brytpunkt anger du felsökningsmiljön. Kommandotolken ändras så att den börjar med "[DBG]:".

Mer information om hur du anpassar prompten finns i about_Prompts.

I vissa värdprogram, till exempel PowerShell-konsolen (men inte i Windows PowerShell Integrated Scripting Environment [ISE]), öppnas en kapslad prompt för felsökning. Du kan identifiera den kapslade prompten genom att upprepa fler-än-tecken (ASCII 62) som visas i kommandotolken.

Till exempel är följande standardfelsökningsfråga i PowerShell-konsolen:

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

Du hittar kapslingsnivån med hjälp av den $NestedPromptLevel automatiska variabeln.

Dessutom definieras en automatisk variabel, $PSDebugContext , i det lokala omfånget. Du kan använda förekomsten av $PsDebugContext variabeln för att avgöra om du befinner dig i felsökningsprogrammet.

Exempel:

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

Du kan använda värdet för $PSDebugContext variabeln i felsökningen.

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

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

Felsökning och omfång

Inbrott i felsökningsprogrammet ändrar inte omfånget där du arbetar, men när du når en brytpunkt i ett skript går du vidare till skriptomfånget. Skriptomfånget är under det omfång där du körde felsökningsprogrammet.

Om du vill hitta de variabler och alias som definieras i skriptomfånget använder du scopeparametern för Get-Alias Get-Variable cmdletarna eller .

Följande kommando hämtar till exempel variablerna i det lokala omfånget (skript):

Get-Variable -scope 0

Du kan förkorta kommandot så här:

gv -s 0

Det här är ett användbart sätt att bara se de variabler som du definierade i skriptet och som du definierade vid felsökning.

Felsökning på kommandoraden

När du anger en variabel brytpunkt eller en kommando brytpunkt kan du ange brytpunkten endast i en skriptfil. Som standard är brytpunkten dock inställd på allt som körs i den aktuella sessionen.

Om du till exempel anger en brytpunkt för variabeln bryts felsökaren på alla variabler i alla $name $name skript, kommandon, funktioner, skript-cmdlet eller uttryck som du kör tills du inaktiverar eller tar bort brytpunkten.

På så sätt kan du felsöka skript i en mer realistisk kontext där de kan påverkas av funktioner, variabler och andra skript i sessionen och i användarens profil.

Radbrytningspunkter är specifika för skriptfiler, så de anges bara i skriptfiler.

Felsökningsfunktioner

När du anger en brytpunkt för en funktion som har avsnitten , och bryts Begin Process End felsökningsprogrammet på den första raden i varje avsnitt.

Exempel:

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>

Felsöka fjärrskript

Från och med PowerShell 5.0 kan du köra PowerShell-felsökaren i en fjärrsession, antingen i -konsolen eller Windows PowerShell ISE. Enter-PSSession funktionen har uppdaterats så att du kan återansluta till och ange en frånkopplad session som körs på en fjärrdator och som för närvarande kör ett skript. Om skriptet som körs når en brytpunkt startar klientsessionen automatiskt felsökningsprogrammet.

Följande är ett exempel som visar hur det fungerar, med brytpunkter inställda i ett skript på raderna 6, 11, 22 och 25. Observera att när felsökningsprogrammet startar i exemplet finns det två identifieringsuppmaning: namnet på datorn där sessionen körs och DBG-prompten som talar om att du är i felsökningsläge.

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>

Exempel

Det här testskriptet identifierar versionen av operativsystemet och visar ett system lämpligt meddelande. Den innehåller en funktion, ett funktionsanrop och en variabel.

Följande kommando visar innehållet i testskriptfilen:

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

Starta genom att ange en brytpunkt vid en punkt av intresse i skriptet, till exempel en rad, ett kommando, en variabel eller en funktion.

Börja med att skapa en radbrytningspunkt på den första raden Test.ps1 skriptet i den aktuella katalogen.

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

Du kan förkorta det här kommandot så här:

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

Kommandot returnerar ett line-breakpoint-objekt (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

Starta nu skriptet.

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

När skriptet når den första brytpunkten indikerar brytpunktens meddelande att felsökaren är aktiv. Den beskriver brytpunkten och förhandsgranskar den första raden i skriptet, som är en funktionsdeklaration. Kommandotolken ändras också för att indikera att felsökaren har kontroll.

Förhandsgranskningsraden innehåller skriptnamnet och radnumret för det förhandsgranskade kommandot.

Entering debug mode. Use h or ? for help.

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

test.ps1:1   function psversion {
# DBG>

Använd step-kommandot (s) för att köra den första instruktionen i skriptet och för att förhandsgranska nästa instruktion. Nästa instruktion använder den $MyInvocation automatiska variabeln för att ange värdet för $scriptName variabeln till sökvägen och filnamnet för skriptfilen.

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

I det här läget är $scriptName variabeln inte ifylld, men du kan verifiera värdet för variabeln genom att visa dess värde. I det här fallet är värdet $null .

DBG> $scriptname
# DBG>

Använd ett annat stegkommando (er) för att köra den aktuella instruktionen och för att förhandsgranska nästa instruktion i skriptet. Nästa instruktion anropar funktionen PsVersion.

DBG> s
test.ps1:12  psversion

Nu fylls $scriptName variabeln i, men du verifierar värdet för variabeln genom att visa dess värde. I det här fallet är värdet inställt på skriptsökvägen.

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

Använd ett annat stegkommando för att köra funktionsanropet. Tryck på RETUR eller skriv "s" för Steg.

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

Felsökningsmeddelandet innehåller en förhandsgranskning av -instruktionen i funktionen. Om du vill köra den här instruktionen och förhandsgranska nästa instruktion i funktionen kan du använda ett Step kommando. Men i det här fallet använder du ett StepOut-kommando (o). Den slutför körningen av funktionen (om den inte når en brytpunkt) och går vidare till nästa instruktion i skriptet.

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

Eftersom vi är på den sista instruktionen i skriptet har kommandona Step, StepOut och Continue samma effekt. I det här fallet använder du StepOut (o).

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

StepOut-kommandot kör det sista kommandot. Standardkommandot anger att felsökaren har avslutats och returnerat kontrollen till kommandoprocessorn.

Kör nu felsökningsprogrammet igen. För att ta bort den aktuella brytpunkten använder du Get-PsBreakpoint Remove-PsBreakpoint cmdletarna och . (Om du tror att du kan återanvända brytpunkten använder du Disable-PsBreakpoint cmdleten i stället för Remove-PsBreakpoint .)

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

Du kan förkorta det här kommandot så här:

PS C:\ps-test> gbp | rbp

Eller så kan du köra kommandot genom att skriva en funktion, till exempel följande funktion:

function delbr { gbp | rbp }

Skapa nu en brytpunkt för $scriptname variabeln .

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

Du kan förkorta kommandot så här:

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

Starta nu skriptet. Skriptet når variabeln brytpunkt. Standardläget är Write, så körningen stoppas precis före instruktionen som ändrar värdet för variabeln.

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>

Visar det aktuella värdet för $scriptName variabeln, som är $null .

DBG> $scriptName
# DBG>

Använd ett stegkommando (s) för att köra instruktionen som fyller variabeln. Visa sedan det nya värdet för $scriptName variabeln.

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

Nästa instruktion är ett anrop till funktionen PsVersion. Om du vill hoppa över funktionen men ändå köra den använder du ett StepOver-kommando (v). Om du redan använder funktionen när du använder StepOver är den inte effektiv. Funktionsanropet visas, men det körs inte.

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

StepOver-kommandot kör funktionen och förhandsgranskar nästa instruktion i skriptet, som skriver ut den sista raden.

Använd ett stoppkommando (t) för att avsluta felsökningsprogrammet. Kommandotolken återgår till den vanliga kommandotolken.

C:\ps-test>

Om du vill ta bort brytpunkterna använder du Get-PsBreakpoint Remove-PsBreakpoint cmdletarna och .

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

Skapa en ny kommandobrytningspunkt för funktionen PsVersion.

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

Du kan förkorta det här kommandot för att:

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

Kör nu skriptet.

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

test.ps1:12  psversion
# DBG>

Skriptet når brytpunkten vid funktionsanropet. Nu har funktionen ännu inte anropats. Detta ger dig möjlighet att använda parametern Åtgärd för för att ange villkor för körning av brytpunkten eller utföra förberedande eller diagnostiska uppgifter, till exempel starta en logg eller anrop av ett diagnostik- eller Set-PSBreakpoint säkerhetsskript.

Om du vill ange en åtgärd använder du kommandot Fortsätt (c) för att avsluta skriptet och ett kommando Remove-PsBreakpoint för att ta bort den aktuella brytpunkten. (Brytpunkter är skrivskyddade, så du kan inte lägga till en åtgärd till den aktuella brytpunkten.)

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>

Skapa nu en ny kommandobrytningspunkt med en åtgärd. Följande kommando anger en kommando brytpunkt med en åtgärd som loggar värdet för $scriptName variabeln när funktionen anropas. Eftersom nyckelordet Break inte används i åtgärden stoppas inte körningen. (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}

Du kan också lägga till åtgärder som anger villkor för brytpunkten. I följande kommando körs bara kommando brytpunkten om körningsprincipen är inställd på RemoteSigned, den mest restriktiva principen som fortfarande tillåter dig att köra skript. (Bakåtklicket ()) är fortsättningstecknet.)

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

Nyckelordet Break i åtgärden dirigerar felsökningsprogrammet att köra brytpunkten. Du kan också använda nyckelordet Fortsätt för att dirigera felsökningsprogrammet att köras utan att det bryts. Eftersom standardnyckelordet är Fortsätt måste du ange Bryt om du vill stoppa körningen.

Kör nu skriptet.

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

test.ps1:12  psversion

Eftersom körningsprincipen är inställd på RemoteSigned stoppas körningen vid funktionsanropet.

Nu kanske du vill kontrollera anropsstacken. Använd Get-PsCallStack cmdleten eller Get-PsCallStack felsökningskommandot (k). Följande kommando hämtar den aktuella anropsstacken.

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

Det här exemplet visar bara några av de många sätten att använda PowerShell-felsökaren.

Om du vill ha mer information om felsöknings-cmdlets skriver du följande kommando:

help <cmdlet-name> -full

Skriv till exempel:

help Set-PSBreakpoint -full

Andra felsökningsfunktioner i PowerShell

Förutom PowerShell-felsökaren innehåller PowerShell flera andra funktioner som du kan använda för att felsöka skript och funktioner.

  • Windows PowerShell ISE innehåller ett interaktivt grafiskt felsökningsalternativ. Mer information finns i starta Windows PowerShell ISE trycka på F1.

  • Set-PSDebugCmdleten erbjuder mycket grundläggande funktioner för felsökning av skript, inklusive stegning och spårning.

  • Använd cmdleten för att identifiera referenser till oinitialiserade variabler, referenser till obefintliga egenskaper för ett objekt och för att Set-StrictMode funktionssyntax som inte är giltig.

  • Lägg till diagnostikinstruktioner i ett skript, till exempel instruktioner som visar värdet för variabler, instruktioner som läser indata från kommandoraden eller instruktioner som rapporterar den aktuella instruktionen. Använd de cmdlets som innehåller write-verbet för den här uppgiften, till Write-Host exempel , , och Write-Debug Write-Warning Write-Verbose .

SE ÄVEN