Notitie
Voor toegang tot deze pagina is autorisatie vereist. U kunt proberen u aan te melden of de directory te wijzigen.
Voor toegang tot deze pagina is autorisatie vereist. U kunt proberen de mappen te wijzigen.
KORTE BESCHRIJVING
Hierin wordt het Foutopsporingsprogramma van PowerShell beschreven.
LANGE BESCHRIJVING
Foutopsporing is het proces waarbij een script wordt onderzocht terwijl het wordt uitgevoerd om fouten in de scriptinstructies te identificeren en te corrigeren. Met het PowerShell-foutopsporingsprogramma kunt u fouten en inefficiënties in uw scripts, functies, opdrachten, PowerShell-werkstromen, PowerShell Desired State Configuration (DSC)-configuraties of expressies onderzoeken en identificeren.
Vanaf PowerShell 5.0 is het PowerShell-foutopsporingsprogramma bijgewerkt om fouten op te sporen in scripts, functies, werkstromen, opdrachten, configuraties of expressies die worden uitgevoerd in de console of Windows PowerShell ISE op externe computers. U kunt Enter-PSSession uitvoeren om een interactieve externe PowerShell-sessie te starten waarin u onderbrekingspunten kunt instellen en scriptbestanden en opdrachten op de externe computer kunt opsporen.
Enter-PSSession De functionaliteit is bijgewerkt, zodat u opnieuw verbinding kunt maken met een sessie waarbij de verbinding verbroken is en waarin een script of opdracht wordt uitgevoerd op een externe computer. Als het actieve script een onderbrekingspunt bereikt, start uw clientsessie automatisch het foutopsporingsprogramma. Als de verbroken sessie waarop een script wordt uitgevoerd, al een onderbrekingspunt heeft bereikt en op het onderbrekingspunt wordt gestopt, Enter-PSSession wordt automatisch het foutopsporingsprogramma voor de opdrachtregel gestart nadat u opnieuw verbinding hebt gemaakt met de sessie.
Het PowerShell-foutopsporingsprogramma kan ook worden gebruikt voor het opsporen van fouten in PowerShell-werkstromen, in de PowerShell-console of in Windows PowerShell ISE. Vanaf PowerShell 5.0 kunt u fouten opsporen in actieve taken of processen, lokaal of extern.
U kunt de functies van het PowerShell-foutopsporingsprogramma gebruiken om een PowerShell-script, -functie, -opdracht, -werkstroom of -expressie te onderzoeken terwijl deze wordt uitgevoerd. Het PowerShell-foutopsporingsprogramma bevat een set cmdlets waarmee u onderbrekingspunten kunt instellen, onderbrekingspunten kunt beheren en de aanroepstack kunt weergeven.
Debugger Cmdlets
Het PowerShell-foutopsporingsprogramma bevat de volgende set cmdlets:
-
Set-PSBreakpoint: hiermee stelt u onderbrekingspunten in op regels, variabelen en opdrachten. -
Get-PSBreakpoint: Krijgt onderbrekingspunten in de huidige sessie. -
Disable-PSBreakpoint: schakelt onderbrekingspunten in de huidige sessie uit. -
Enable-PSBreakpoint: onderbrekingspunten in de huidige sessie opnieuw inschakelen. -
Remove-PSBreakpoint: hiermee verwijdert u onderbrekingspunten uit de huidige sessie. -
Get-PSCallStack: geeft de huidige aanroepstack weer.
De debugger starten en stoppen
Als u het foutopsporingsprogramma wilt starten, stelt u een of meer onderbrekingspunten in. Voer vervolgens het script, de opdracht of de functie uit waarvan u fouten wilt opsporen.
Wanneer u een onderbrekingspunt bereikt, stopt de uitvoering en wordt het besturingselement overgezet naar het foutopsporingsprogramma.
Als u de foutopsporing wilt stoppen, voert u het script, de opdracht of de functie uit totdat deze is voltooid. Of typ stop of t.
Opdrachten voor foutopsporingsprogramma
Wanneer u het foutopsporingsprogramma in de PowerShell-console gebruikt, gebruikt u de volgende opdrachten om de uitvoering te beheren. Gebruik in Windows PowerShell ISE opdrachten in het menu Foutopsporing.
Opmerking: Zie de documentatie van de hosttoepassing voor informatie over het gebruik van het foutopsporingsprogramma in andere hosttoepassingen.
s,StepInto: voert de volgende instructie uit en stopt.v,StepOver: Voert de volgende instructie uit, maar slaat functies en aanroepen over. De overgeslagen instructies worden uitgevoerd, maar niet stap voor stap doorlopen.Ctrl+Break: (Alles onderbreken in ISE) Breekt een actief script in in de PowerShell-console of Windows PowerShell ISE. Houd er rekening mee dat Ctrl+einde van in Windows PowerShell 2.0, 3.0 en 4.0 het programma sluit. Break All werkt zowel op lokale als op afstand interactief uitgevoerde scripts.o,StepOut: Stappen uit de huidige functie; één niveau omhoog als ze genest zijn. Als deze zich in de hoofdtekst bevindt, gaat het verder naar het einde of het volgende onderbrekingspunt. De overgeslagen instructies worden uitgevoerd, maar niet stap voor stap doorlopen.c,Continue: wordt uitgevoerd totdat het script is voltooid of totdat het volgende onderbrekingspunt is bereikt. De overgeslagen instructies worden uitgevoerd, maar niet stap voor stap doorlopen.l,List: Geeft het deel van het script weer dat wordt uitgevoerd. Standaard worden de huidige regel, vijf vorige regels en 10 volgende regels weergegeven. Druk op Enter om door te gaan met het weergeven van het script.l <m>,List: Geeft 16 regels van het script weer die beginnen met het regelnummer dat is opgegeven door<m>.l <m> <n>,List: Geeft<n>regels van het script weer, beginnend met het regelnummer dat is opgegeven door<m>.q,Stop,Exit: stopt met het uitvoeren van het script en sluit het foutopsporingsprogramma af. Als u fouten in een taak opspoort door de cmdletDebug-Jobuit te voeren, wordt met deExitopdracht het foutopsporingsprogramma losgekoppeld en kan de taak worden uitgevoerd.k,Get-PsCallStack: Geeft de huidige aanroepstack weer.<Enter>: Herhaalt de laatste opdracht als dit Stap (s), Stap Over (v) of Lijst (l) was. Anders vertegenwoordigt u een verzendactie.?,h: Geeft de Help voor foutopsporingsprogramma weer.
Als u de foutopsporing wilt afsluiten, kunt u Stop (q) gebruiken.
Vanaf PowerShell 5.0 kunt u de opdracht Afsluiten uitvoeren om een geneste foutopsporingssessie af te sluiten die u hebt gestart door Debug-Job of Debug-Runspaceuit te voeren.
Met behulp van deze opdrachten voor foutopsporing kunt u een script uitvoeren, stoppen bij een probleem, de waarden van variabelen en de status van het systeem onderzoeken en het script blijven uitvoeren totdat u een probleem hebt geïdentificeerd.
OPMERKING: Als u in een instructie stapt met een omleidingsoperator, zoals ">", stapt het PowerShell-foutopsporingsprogramma over alle resterende instructies in het script.
De waarden van scriptvariabelen weergeven
Terwijl u zich in het foutopsporingsprogramma bevindt, kunt u ook opdrachten invoeren, de waarde van variabelen weergeven, cmdlets gebruiken en scripts uitvoeren op de opdrachtregel.
U kunt de huidige waarde weergeven van alle variabelen in het script waarvoor fouten worden opgespoord, met uitzondering van de volgende automatische variabelen:
$_
$Args
$Input
$MyInvocation
$PSBoundParameters
Als u de waarde van een van deze variabelen probeert weer te geven, krijgt u de waarde van die variabele in een interne pijplijn waarvoor het foutopsporingsprogramma gebruikmaakt, niet de waarde van de variabele in het script.
Als u de waarde van deze variabelen wilt weergeven voor het script waarvoor fouten worden opgespoord, wijst u in het script de waarde van de automatische variabele toe aan een nieuwe variabele. Vervolgens kunt u de waarde van de nieuwe variabele weergeven.
Bijvoorbeeld
$scriptArgs = $Args
$scriptArgs
In het voorbeeld in dit onderwerp wordt de waarde van de $MyInvocation variabele als volgt opnieuw toegewezen:
$scriptname = $MyInvocation.MyCommand.Path
De omgeving van de debugger
Wanneer u een onderbrekingspunt bereikt, voert u de foutopsporingsprogrammaomgeving in. De opdrachtprompt verandert zodat deze begint met [DBG]:. Als u fouten oploopt in een werkstroom, is de prompt "[WFDBG]". U kunt de prompt aanpassen.
Zie about_Promptsvoor meer informatie over het aanpassen van de prompt.
In sommige hosttoepassingen, zoals de PowerShell-console (maar niet in Windows PowerShell Integrated Scripting Environment [ISE]), wordt ook een geneste prompt geopend voor foutopsporing. U kunt de geneste prompt detecteren door de herhalende tekens (ASCII 62) die worden weergegeven bij de opdrachtprompt.
Het volgende is bijvoorbeeld de standaardprompt voor foutopsporing in de PowerShell-console:
[DBG]: PS (get-location)>>>
U kunt het nestniveau vinden met behulp van de $NestedPromptLevel automatische variabele.
Bovendien wordt een automatische variabele, $PSDebugContext, gedefinieerd in het lokale bereik. U kunt de aanwezigheid van de $PsDebugContext variabele gebruiken om te bepalen of u zich in de foutopsporingsmachine bevindt.
Voorbeeld:
if ($PSDebugContext) {"Debugging"} else {"Not Debugging"}
U kunt de waarde van de $PSDebugContext variabele in uw foutopsporing gebruiken.
[DBG]: PS>>> $PSDebugContext.InvocationInfo
Name CommandLineParameters UnboundArguments Location
---- --------------------- ---------------- --------
= {} {} C:\ps-test\vote.ps1 (1)
Foutopsporing en bereik
Als u inbreekt in het foutopsporingsprogramma, wordt het bereik waarin u werkt niet gewijzigd, maar wanneer u een onderbrekingspunt in een script bereikt, gaat u naar het scriptbereik. Het scriptbereik is een onderliggend element van het bereik waarin u het foutopsporingsprogramma hebt uitgevoerd.
Als u de variabelen en aliassen wilt vinden die zijn gedefinieerd in het scriptbereik, gebruikt u de parameter Bereik van de Get-Alias of Get-Variable-cmdlets.
Met de volgende opdracht worden bijvoorbeeld de variabelen in het lokale bereik (script) ophaalt:
Get-Variable -scope 0
U kunt de opdracht verkorten als:
gv -s 0
Dit is een handige manier om alleen de variabelen te zien die u in het script hebt gedefinieerd en die u hebt gedefinieerd tijdens foutopsporing.
Debuggen op de opdrachtregel
Wanneer u een variabele onderbrekingspunt of een opdrachtonderbrekingspunt instelt, kunt u het onderbrekingspunt alleen instellen in een scriptbestand. Standaard is het onderbrekingspunt echter ingesteld op alles wat in de huidige sessie wordt uitgevoerd.
Als u bijvoorbeeld een onderbrekingspunt instelt op de $name variabele, wordt het foutopsporingsprogramma onderbroken op een willekeurige $name variabele in een script, opdracht, functie, script-cmdlet of expressie die u uitvoert totdat u het onderbrekingspunt uitschakelt of verwijdert.
Hierdoor kunt u fouten opsporen in uw scripts in een realistischere context waarin deze mogelijk worden beïnvloed door functies, variabelen en andere scripts in de sessie en in het profiel van de gebruiker.
Regelonderbrekingspunten zijn specifiek voor scriptbestanden, dus ze worden alleen in scriptbestanden ingesteld.
Foutopsporingswerkstromen
Het PowerShell 4.0-foutopsporingsprogramma kan worden gebruikt om fouten op te sporen in PowerShell-werkstromen, in de PowerShell-console of in Windows PowerShell ISE. Er zijn enkele beperkingen met het powerShell-foutopsporingsprogramma voor het opsporen van fouten in werkstromen.
- U kunt werkstroomvariabelen weergeven terwijl u zich in het foutopsporingsprogramma bevindt, maar het instellen van werkstroomvariabelen vanuit het foutopsporingsprogramma wordt niet ondersteund.
- Tabbladvoltooiing wanneer deze is gestopt in het werkstroomfoutopsporingsprogramma is niet beschikbaar.
- Foutopsporing in werkstromen werkt alleen met synchrone uitvoering van werkstromen vanuit een PowerShell-script. U kunt geen fouten opsporen in werkstromen als ze als een taak worden uitgevoerd (met de parameter AsJob ).
- Andere geneste foutopsporingsscenario's, zoals een werkstroom die een andere werkstroom aanroept of een werkstroom die een script aanroept, worden niet geïmplementeerd.
In het volgende voorbeeld ziet u hoe u fouten in een werkstroom kunt opsporen. Wanneer het foutopsporingsprogramma in de werkstroomfunctie stapt, verandert de foutopsporingsprompt in "[WFDBG]".
PS C:> Set-PSBreakpoint -Script C:\TestWFDemo1.ps1 -Line 8
ID Script Line Command Variable Action
-- ------ ---- ------- -------- ------
0 TestWFDemo1.ps1 8
PS C:> C:\TestWFDemo1.ps1
Entering debug mode. Use h or ? for help.
Hit Line breakpoint on 'C:\TestWFDemo1.ps1:8'
At C:\TestWFDemo1.ps1:8 char:5
+ Write-Output -InputObject "Now writing output:"
# +!INCLUDE[]~~~~~
[WFDBG:localhost]: PS C:>> list
# 3:
4: workflow SampleWorkflowTest
5: {
6: param ($MyOutput)
# 7:
8:* Write-Output -InputObject "Now writing output:"
9: Write-Output -Input $MyOutput
# 10:
11: Write-Output -InputObject "Get PowerShell process:"
12: Get-Process -Name powershell
# 13:
14: Write-Output -InputObject "Workflow function complete."
15: }
# 16:
17: # Call workflow function
18: SampleWorkflowTest -MyOutput "Hello"
[WFDBG:localhost]: PS C:>> $MyOutput
Hello
[WFDBG:localhost]: PS C:>> stepOver
Now writing output:
At C:\TestWFDemo1.ps1:9 char:5
+ Write-Output -Input $MyOutput
# +!INCLUDE[]~
[WFDBG:localhost]: PS C:>> list
4: workflow SampleWorkflowTest
5: {
6: param ($MyOutput)
# 7:
8: Write-Output -InputObject "Now writing output:"
9:* Write-Output -Input $MyOutput
# 10:
11: Write-Output -InputObject "Get PowerShell process:"
12: Get-Process -Name powershell
# 13:
14: Write-Output -InputObject "Workflow function complete."
15: }
# 16:
17: # Call workflow function
18: SampleWorkflowTest -MyOutput "Hello"
# 19:
[WFDBG:localhost]: PS C:>> stepOver
Hello
At C:\TestWFDemo1.ps1:11 char:5
+ Write-Output -InputObject "Get PowerShell process:"
# +!INCLUDE[]~~~~~~~~~
[WFDBG:localhost]: PS C:>> stepOut
Get PowerShell process:
Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName
------- ------ ----- ----- ----- ------ -- -----------
433 35 106688 128392 726 2.67 7124 powershell
499 44 134244 172096 787 2.79 7452 powershell
Workflow function complete.
Foutopsporingsfuncties
Wanneer u een onderbrekingspunt instelt voor een functie met Begin, Processen End secties, wordt het foutopsporingsprogramma afgebroken op de eerste regel van elke sectie.
Voorbeeld:
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>
Fouten opsporen in externe scripts
Vanaf PowerShell 5.0 kunt u het PowerShell-foutopsporingsprogramma uitvoeren in een externe sessie, in de console of Windows PowerShell ISE.
Enter-PSSession De functionaliteit is bijgewerkt, zodat u opnieuw verbinding kunt maken met een sessie waarvan de verbinding verbroken is en die wordt uitgevoerd op een externe computer en waarop momenteel een script wordt uitgevoerd. Als het actieve script een onderbrekingspunt bereikt, start uw clientsessie automatisch het foutopsporingsprogramma.
Het volgende is een voorbeeld dat laat zien hoe dit werkt, met onderbrekingspunten die in een script zijn ingesteld op regels 6, 11, 22 en 25. Houd er rekening mee dat er in het voorbeeld, wanneer het foutopsporingsprogramma wordt gestart, twee identificerende prompts zijn: de naam van de computer waarop de sessie wordt uitgevoerd en de DBG-prompt die u laat weten dat u zich in de foutopsporingsmodus bevindt.
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>
Voorbeelden
Dit testscript detecteert de versie van het besturingssysteem en geeft een bericht weer dat geschikt is voor het systeem. Het bevat een functie, een functie-aanroep en een variabele.
Met de volgende opdracht wordt de inhoud van het testscriptbestand weergegeven:
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."
Als u wilt beginnen, stelt u een onderbrekingspunt in op een nuttige plaats in het script, zoals een regel, opdracht, variabele of functie.
Begin met het maken van een regeleindepunt op de eerste regel van het Test.ps1 script in de huidige map.
PS C:\ps-test> Set-PSBreakpoint -line 1 -script test.ps1
U kunt deze opdracht verkorten als:
PS C:\ps-test> spb 1 -s test.ps1
De opdracht retourneert een regel-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
Start nu het script.
PS C:\ps-test> .\test.ps1
Wanneer het script het eerste onderbrekingspunt bereikt, geeft het onderbrekingspuntbericht aan dat het foutopsporingsprogramma actief is. Het beschrijft het onderbrekingspunt en bekijkt de eerste regel van het script, een functiedeclaratie. De opdrachtprompt verandert ook om aan te geven dat het foutopsporingsprogramma controle heeft.
De preview-regel bevat de scriptnaam en het regelnummer van de voorbeeldopdracht.
Entering debug mode. Use h or ? for help.
Hit Line breakpoint on 'C:\ps-test\test.ps1:1'
test.ps1:1 function psversion {
# DBG>
Gebruik de opdracht Stap (s) om de eerste instructie in het script uit te voeren en een voorbeeld van de volgende instructie te bekijken. De volgende instructie maakt gebruik van de automatische $MyInvocation variabele om de waarde van de $scriptName variabele in te stellen op het pad en de bestandsnaam van het scriptbestand.
DBG> s
test.ps1:11 $scriptName = $MyInvocation.MyCommand.Path
Op dit moment is de $scriptName variabele nog niet ingevuld, maar u kunt de waarde van de variabele verifiëren door de waarde weer te geven. In dit geval is $nullde waarde .
DBG> $scriptname
# DBG>
Gebruik een andere Step-opdracht (en) om de huidige instructie uit te voeren en een voorbeeld van de volgende instructie in het script te bekijken. De volgende instructie roept de PsVersion-functie aan.
DBG> s
test.ps1:12 psversion
Op dit moment wordt de $scriptName variabele ingevuld, maar u controleert de waarde van de variabele door de waarde ervan weer te geven. In dit geval wordt de waarde ingesteld op het scriptpad.
DBG> $scriptName
C:\ps-test\test.ps1
Gebruik een andere stapopdracht om de functie-aanroep uit te voeren. Druk op Enter of typ 's' voor stap.
DBG> s
test.ps1:2 "PowerShell " + $PSVersionTable.PSVersion
Het foutopsporingsbericht bevat een voorbeeld van de instructie in de functie. Als u deze instructie wilt uitvoeren en een voorbeeld van de volgende instructie in de functie wilt bekijken, kunt u een Step opdracht gebruiken. In dit geval gebruikt u echter een StepOut-opdracht (o). Hiermee wordt de uitvoering van de functie voltooid (tenzij deze een onderbrekingspunt bereikt) en stappen naar de volgende instructie in het script.
DBG> o
Windows PowerShell 2.0
Have you run a background job today (start-job)?
test.ps1:13 "Done $scriptName"
Omdat we bij de laatste instructie in het script zijn, hebben de opdrachten Stap, StapOut en Doorgaan hetzelfde effect. In dit geval gebruikt u StepOut (o).
Done C:\ps-test\test.ps1
PS C:\ps-test>
Met de StepOut-opdracht wordt de laatste opdracht uitgevoerd. De standaardopdrachtprompt geeft aan dat het foutopsporingsprogramma is afgesloten en het besturingselement heeft geretourneerd naar de opdrachtprocessor.
Voer nu het foutopsporingsprogramma opnieuw uit. Als u eerst het huidige onderbrekingspunt wilt verwijderen, gebruikt u de cmdlets Get-PSBreakpoint en Remove-PSBreakpoint. (Als u denkt dat u het onderbrekingspunt mogelijk opnieuw gebruikt, gebruikt u de cmdlet Disable-PSBreakpoint in plaats van Remove-PSBreakpoint.)
PS C:\ps-test> Get-PSBreakpoint| Remove-PSBreakpoint
U kunt deze opdracht verkorten als:
PS C:\ps-test> gbp | rbp
Of voer de opdracht uit door een functie te schrijven, zoals de volgende functie:
function delbr { gbp | rbp }
Maak nu een onderbrekingspunt op de variabele $scriptname.
PS C:\ps-test> Set-PSBreakpoint -variable scriptname -script test.ps1
U kunt de opdracht verkorten als:
PS C:\ps-test> sbp -v scriptname -s test.ps1
Start nu het script. Het script bereikt het onderbrekingspunt van de variabele. De standaardmodus is Schrijven, dus de uitvoering stopt vlak voor de instructie waarmee de waarde van de variabele wordt gewijzigd.
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>
De huidige waarde van de variabele $scriptName weergeven, die $nullis.
DBG> $scriptName
# DBG>
Gebruik een of meer Stap-opdrachten om de instructie uit te voeren waarmee de variabele wordt ingevuld.
Geef vervolgens de nieuwe waarde van de variabele $scriptName weer.
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
De volgende instructie is een aanroep naar de PsVersion-functie. Als u de functie wilt overslaan maar toch wilt uitvoeren, gebruikt u een StepOver-opdracht (v). Als u zich al in de functie bevindt wanneer u StepOver gebruikt, is deze niet effectief. De functieaanroep wordt weergegeven, maar niet uitgevoerd.
DBG> v
Windows PowerShell 2.0
Have you run a background job today (start-job)?
test.ps1:13 "Done $scriptName"
De StepOver-opdracht voert de functie uit en geeft een voorbeeld van de volgende instructie in het script, waarmee de laatste regel wordt afgedrukt.
Gebruik een Stop-opdracht (t) om de foutopsporing af te sluiten. De opdrachtprompt wordt teruggezet naar de standaardopdrachtprompt.
C:\ps-test>
Als u de onderbrekingspunten wilt verwijderen, gebruikt u de cmdlets Get-PSBreakpoint en Remove-PSBreakpoint.
PS C:\ps-test> Get-PSBreakpoint| Remove-PSBreakpoint
Maak een nieuw opdrachtonderbrekingspunt op de PsVersion-functie.
PS C:\ps-test> Set-PSBreakpoint -command psversion -script test.ps1
U kunt deze opdracht verkorten tot:
PS C:\ps-test> sbp -c psversion -s test.ps1
Voer nu het script uit.
PS C:\ps-test> .\test.ps1
Hit Command breakpoint on 'C:\ps-test\test.ps1:psversion'
test.ps1:12 psversion
# DBG>
Het script bereikt het onderbrekingspunt bij de functie-aanroep. Op dit moment is de functie nog niet aangeroepen. Hiermee kunt u de actieparameter van Set-PSBreakpoint gebruiken om voorwaarden in te stellen voor de uitvoering van het onderbrekingspunt of om voorbereidende of diagnostische taken uit te voeren, zoals het starten van een logboek of het aanroepen van een diagnostisch of beveiligingsscript.
Als u een actie wilt instellen, gebruikt u een opdracht Doorgaan (c) om het script af te sluiten en een Remove-PSBreakpoint opdracht om het huidige onderbrekingspunt te verwijderen. (Breekpunten zijn alleen-lezen, dus u kunt geen actie toevoegen aan het huidige onderbrekingspunt.)
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>
Maak nu een nieuw onderbrekingspunt voor opdrachten met een actie. Met de volgende opdracht wordt een onderbrekingspunt voor opdrachten ingesteld met een actie waarmee de waarde van de $scriptName variabele wordt vastgelegd wanneer de functie wordt aangeroepen. Omdat het trefwoord Onderbreking niet wordt gebruikt in de actie, stopt de uitvoering niet. (De backtick (') is het teken voor de voortzetting van de regel.)
PS C:\ps-test> Set-PSBreakpoint -command psversion -script test.ps1 `
-action { add-content "The value of `$scriptName is $scriptName." `
-path action.log}
U kunt ook acties toevoegen waarmee voorwaarden voor het onderbrekingspunt worden ingesteld. In de volgende opdracht wordt het onderbrekingspunt van de opdracht alleen uitgevoerd als het uitvoeringsbeleid is ingesteld op RemoteSigned, het meest beperkende beleid waarmee u nog steeds scripts kunt uitvoeren. (De backtick (') is het vervolgteken.)
PS C:\ps-test> Set-PSBreakpoint -script test.ps1 -command psversion `
-action { if ((Get-ExecutionPolicy) -eq "RemoteSigned") { break }}
Het trefwoord Onderbreking in de actie geeft het foutopsporingsprogramma de opdracht om het onderbrekingspunt uit te voeren. U kunt het trefwoord Doorgaan ook gebruiken om het foutopsporingsprogramma opdracht te geven om uit te voeren zonder te onderbreken. Omdat het standaardtrefwoord Doorgaan is, moet u Onderbreking opgeven om de uitvoering te stoppen.
Voer nu het script uit.
PS C:\ps-test> .\test.ps1
Hit Command breakpoint on 'C:\ps-test\test.ps1:psversion'
test.ps1:12 psversion
Omdat het uitvoeringsbeleid is ingesteld op RemoteSigned, stopt de uitvoering bij de functieaanroep.
Op dit moment wilt u mogelijk de aanroepstack controleren. Gebruik de Get-PsCallStack cmdlet of de Get-PsCallStack opdracht debugger (k). Met de volgende opdracht wordt de huidige aanroepstack ophaalt.
DBG> k
2: prompt
1: .\test.ps1: $args=[]
0: prompt: $args=[]
In dit voorbeeld ziet u slechts een paar van de vele manieren om het PowerShell-foutopsporingsprogramma te gebruiken.
Typ de volgende opdracht voor meer informatie over de debugger-cmdlets:
help <cmdlet-name> -full
Typ bijvoorbeeld:
help Set-PSBreakpoint -full
Andere functies voor foutopsporing in PowerShell
Naast het PowerShell-foutopsporingsprogramma bevat PowerShell verschillende andere functies die u kunt gebruiken voor het opsporen van fouten in scripts en functies.
Windows PowerShell ISE bevat een interactief grafisch foutopsporingsprogramma. Start Windows PowerShell ISE voor meer informatie en druk op F1.
De
Set-PSDebugcmdlet biedt zeer eenvoudige script foutopsporingsfuncties, waaronder stappen en tracering.Gebruik de
Set-StrictModecmdlet om verwijzingen naar niet-geïnitialiseerde variabelen te detecteren, naar verwijzingen naar niet-bestaande eigenschappen van een object en naar functiesyntaxis die niet geldig is.Voeg diagnostische instructies toe aan een script, zoals instructies die de waarde van variabelen weergeven, instructies die invoer lezen vanaf de opdrachtregel of instructies die de huidige instructie rapporteren. Gebruik de cmdlets die het schrijfwoord voor deze taak bevatten, zoals
Write-Host,Write-Debug,Write-WarningenWrite-Verbose.