about_Debuggers
Kort beskrivning
Beskriver PowerShell-felsökningsprogrammet.
Lång beskrivning
Felsökning är processen att undersöka ett skript medan det körs för att identifiera och korrigera fel i skriptanvisningarna. PowerShell-felsökningsprogrammet 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ökningsprogrammet uppdaterats för att felsöka skript, funktioner, kommandon, konfigurationer eller uttryck som körs i konsolen eller Windows PowerShell ISE på fjärrdatorer. Du kan köra Enter-PSSession för att starta en interaktiv PowerShell-fjärrsession där du kan ange brytpunkter och felsöka skriptfiler och 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 träffar en brytpunkt startar klientsessionen automatiskt felsökningsprogrammet. Om den frånkopplade sessionen som kör ett skript redan har nått en brytpunkt och stoppas vid brytpunkten startar Enter-PSSession automatiskt kommandoradsfelsökaren när du har återanslutit till sessionen.
Du kan använda funktionerna i PowerShell-felsökningsprogrammet för att undersöka ett PowerShell-skript, en funktion, ett kommando eller ett uttryck när det körs. PowerShell-felsökningsprogrammet innehåller en uppsättning cmdletar som gör att du kan ange brytpunkter, hantera brytpunkter och visa anropsstacken.
Cmdletar för felsökningsprogram
PowerShell-felsökningsprogrammet innehåller följande uppsättning cmdletar:
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: Återaktivering av 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 över 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 använder 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 -instruktionerna körs, men de stegas inte igenom.Ctrl+Break: (Bryt alla i ISE) Delar upp ett skript som körs i PowerShell-konsolen eller Windows PowerShell ISE. Observera att Ctrl+Break in Windows PowerShell 2.0, 3.0 och 4.0 stänger programmet. Break All fungerar på både lokala och fjärranslutna skript 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 -instruktionerna körs, men de stegas inte igenom.c,Continue: Fortsätter att köras tills skriptet har slutförts eller tills nästa brytpunkt har nåtts. De överhoppade -instruktionerna körs, men de stegas 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 om du vill 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<n>rader i skriptet som börjar med radnumret som anges av<m>.q,Stop,Exit: Slutar köra skriptet och avslutar felsökningsprogrammet. Om du felsöker ett jobb genom att köra cmdletenDebug-JobExitkopplar kommandot från felsökaren och tillåter att jobbet fortsätter att köras.k,Get-PsCallStack: Visar den aktuella anropsstacken.<Enter>: Upprepar det sista kommandot om det var Steg (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 antingen Debug-Job eller Debug-Runspace.
Genom att använda dessa felsökningskommandon kan du köra ett skript, stoppa på en punkt av intresse, undersöka värdena för variabler och systemets tillstånd och fortsätta 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ökningsprogrammet över alla återstående instruktioner i skriptet.
Visa värden för skriptvariabler
När du använder felsökningsprogrammet kan du också ange kommandon, visa värdet för variabler, använda cmdletar 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ökaren använder, inte värdet för variabeln i skriptet.
Om du vill visa värdet för de här variablerna för skriptet som felsöks i skriptet tilldelar du 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 omtilldelas värdet för variabeln $MyInvocation 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 även en kapslad uppmaning för felsökning. Du kan identifiera den kapslade prompten genom att upprepa fler än tecken (ASCII 62) som visas i kommandotolken.
Följande är till exempel standardfelsökningsprompten 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 variabeln $PsDebugContext för att avgöra om du är i felsökningsprogrammet.
Exempel:
if ($PSDebugContext) {"Debugging"} else {"Not Debugging"}
Du kan använda värdet för variabeln $PSDebugContext i felsökningen.
[DBG]: PS>>> $PSDebugContext.InvocationInfo
Name CommandLineParameters UnboundArguments Location
---- --------------------- ---------------- --------
= {} {} C:\ps-test\vote.ps1 (1)
Felsökning och omfång
Om du bryter dig in i felsökningsprogrammet ändras inte det omfång som du använder, men när du når en brytpunkt i ett skript flyttas du till skriptomfånget. Skriptomfånget är underordnat det omfång där du körde felsökningsprogrammet.
Om du vill hitta de variabler och alias som definierats i skriptomfånget använder du parametern Get-Alias Scope för cmdletarna eller Get-Variable .
Följande kommando hämtar till exempel variablerna i det lokala omfånget (skript):
Get-Variable -scope 0
Du kan förkorta kommandot som:
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 under felsökningen.
Felsöka på kommandoraden
När du anger en variabel brytpunkt eller en kommandobrytpunkt kan du bara ange brytpunkten i en skriptfil. Men som standard är brytpunkten inställd på allt som körs i den aktuella sessionen.
Om du till exempel anger en brytpunkt för variabeln $name bryts felsökningsprogrammet på valfri $name variabel i alla skript, kommandon, funktioner, skript-cmdletar eller uttryck som du kör tills du inaktiverar eller tar bort brytpunkten.
På så sätt kan du felsöka skripten 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 endast i skriptfiler.
Felsökningsfunktioner
När du anger en brytpunkt för en funktion som har Beginavsnitten , Processoch End bryts 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ökningsprogrammet 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 träffar en brytpunkt startar klientsessionen automatiskt felsökningsprogrammet.
Följande är ett exempel som visar hur detta 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å identifieringsuppmaningar: namnet på den dator där sessionen körs och DBG-prompten som meddelar dig 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 systemanpassat 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."
Börja 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 i 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 som:
PS C:\ps-test> spb 1 -s test.ps1
Kommandot returnerar ett radbrytningspunktsobjekt (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 anger brytpunktsmeddelandet att felsökningsprogrammet är aktivt. Den beskriver brytpunkten och förhandsgranskar den första raden i skriptet, vilket ä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 kommandot Step (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 variabeln $scriptName till sökvägen och filnamnet för skriptfilen.
DBG> s
test.ps1:11 $scriptName = $MyInvocation.MyCommand.Path
Nu är variabeln $scriptName inte ifylld, men du kan verifiera värdet för variabeln genom att visa dess värde. I det här fallet är $nullvärdet .
DBG> $scriptname
# DBG>
Använd ett annat stegkommando (s) för att köra den aktuella instruktionen och för att förhandsgranska nästa instruktion i skriptet. Nästa instruktion anropar PsVersion-funktionen.
DBG> s
test.ps1:12 psversion
Nu fylls variabeln $scriptName i, men du verifierar värdet för variabeln genom att visa dess värde. I det här fallet anges värdet till skriptsökvägen.
DBG> $scriptName
C:\ps-test\test.ps1
Använd ett annat Steg-kommando 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 (såvida 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 använder 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>
Kommandot StepOut kör det sista kommandot. Standardkommandoprompten anger att felsökaren har avslutat och returnerat kontrollen till kommandoprocessorn.
Kör felsökningsprogrammet igen. Börja med att ta bort den aktuella brytpunkten genom att Get-PSBreakpoint använda cmdletarna och Remove-PSBreakpoint . (Om du tror att du kan återanvända brytpunkten använder du cmdleten Disable-PSBreakpoint i stället Remove-PSBreakpointför .)
PS C:\ps-test> Get-PSBreakpoint| Remove-PSBreakpoint
Du kan förkorta det här kommandot som:
PS C:\ps-test> gbp | rbp
Du kan också köra kommandot genom att skriva en funktion, till exempel följande funktion:
function delbr { gbp | rbp }
Skapa nu en brytpunkt för variabeln $scriptname .
PS C:\ps-test> Set-PSBreakpoint -variable scriptname -script test.ps1
Du kan förkorta kommandot som:
PS C:\ps-test> sbp -v scriptname -s test.ps1
Starta nu skriptet. Skriptet når variabelns brytpunkt. Standardläget är Skriv, 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>
Visa det aktuella värdet för variabeln $scriptName , som är $null.
DBG> $scriptName
# DBG>
Använd ett stegkommando (s) för att köra instruktionen som fyller i variabeln.
Visa sedan det nya värdet för variabeln $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
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 standardkommandoprompten.
C:\ps-test>
Om du vill ta bort brytpunkterna Get-PSBreakpoint använder du cmdletarna och Remove-PSBreakpoint .
PS C:\ps-test> Get-PSBreakpoint| Remove-PSBreakpoint
Skapa en ny kommandobrytpunkt i PsVersion-funktionen.
PS C:\ps-test> Set-PSBreakpoint -command psversion -script test.ps1
Du kan förkorta det här kommandot till:
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. I det här läget har funktionen ännu inte anropats. Detta ger dig möjlighet att använda åtgärdsparametern Set-PSBreakpoint för för att ange villkor för körning av brytpunkten eller utföra förberedande eller diagnostiska uppgifter, till exempel att starta en logg eller anropa ett diagnostik- eller säkerhetsskript.
Om du vill ange en åtgärd använder du kommandot Fortsätt (c) för att avsluta skriptet och ett Remove-PSBreakpoint kommando för att ta bort den aktuella brytpunkten. (Brytpunkter är skrivskyddade, så du kan inte lägga till en åtgärd i 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 kommandobrytpunkt med en åtgärd. Följande kommando anger en kommandobrytpunkt med en åtgärd som loggar värdet för variabeln $scriptName när funktionen anropas. Eftersom nyckelordet Break inte används i åtgärden stoppas inte körningen. (Backticken (`) är radfortsättningstecknet.)
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 kommandobrytpunkten endast om körningsprincipen är inställd på RemoteSigned, den mest restriktiva principen som fortfarande tillåter att du kör skript. (Backticken (`) ä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 uppmanar felsökaren att köra brytpunkten. Du kan också använda nyckelordet Fortsätt för att dirigera felsökningsprogrammet så att det körs utan att bryta. Eftersom standardnyckelordet är Fortsätt måste du ange Bryt för att 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 cmdleten Get-PsCallStack eller felsökningskommandot Get-PsCallStack (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ökningsprogrammet.
Om du vill ha mer information om cmdletarna för felsökningsprogrammet 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ökningsprogrammet 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ökningsprogram. Om du vill ha mer information startar du Windows PowerShell ISE och trycker på F1.
Cmdleten
Set-PSDebuginnehåller mycket grundläggande funktioner för felsökning av skript, inklusive steg- och spårning.Använd cmdleten
Set-StrictModeför att identifiera referenser till oinitierade variabler, referenser till icke-existerande egenskaper för ett objekt och till 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 cmdletar som innehåller verbet Write för den här uppgiften, till exempel
Write-Host,Write-Debug,Write-WarningochWrite-Verbose.