Delen via

Over foutopsporingsprogramma's

  • Artikel

KORTE BESCHRIJVING

Beschrijft het PowerShell-foutopsporingsprogramma.

LANGE BESCHRIJVING

Foutopsporing is het proces van het onderzoeken van een script terwijl het wordt uitgevoerd om fouten in de scriptinstructies te identificeren en te corrigeren. Met het Foutopsporingsprogramma van PowerShell kunt u fouten en inefficiënties in uw scripts, functies, opdrachten, PowerShell-werkstromen, DSC-configuraties (PowerShell Desired State Configuration) of expressies onderzoeken en identificeren.

Vanaf PowerShell 5.0 is het Foutopsporingsprogramma van PowerShell 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 uitvoeren Enter-PSSession 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 en een niet-verbonden sessie kunt invoeren die een script of opdracht uitvoert op een externe computer. Als het actieve script een onderbrekingspunt bereikt, wordt het foutopsporingsprogramma automatisch gestart door uw clientsessie. Als de niet-verbonden sessie die een script uitvoert al een onderbrekingspunt heeft bereikt en is gestopt bij het onderbrekingspunt, Enter-PSSession wordt het foutopsporingsprogramma voor de opdrachtregel automatisch gestart nadat u opnieuw verbinding hebt gemaakt met de sessie.

Het PowerShell-foutopsporingsprogramma kan ook worden gebruikt om fouten op te sporen 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 het wordt uitgevoerd. Het Foutopsporingsprogramma van PowerShell bevat een set cmdlets waarmee u onderbrekingspunten kunt instellen, onderbrekingspunten kunt beheren en de aanroepstack kunt weergeven.

Cmdlets voor foutopsporing

Het PowerShell-foutopsporingsprogramma bevat de volgende set cmdlets:

  • Set-PSBreakpoint: Hiermee worden onderbrekingspunten ingesteld voor regels, variabelen en opdrachten.
  • Get-PSBreakpoint: Hiermee worden onderbrekingspunten in de huidige sessie opgeslagen.
  • Disable-PSBreakpoint: Hiermee worden onderbrekingspunten in de huidige sessie uitgeschakeld.
  • Enable-PSBreakpoint: hiermee worden onderbrekingspunten in de huidige sessie opnieuw ingeschakeld.
  • Remove-PSBreakpoint: Hiermee verwijdert u onderbrekingspunten uit de huidige sessie.
  • Get-PSCallStack: Geeft de huidige aanroepstack weer.

Het foutopsporingsprogramma 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 die u wilt opsporen.

Wanneer u een onderbrekingspunt bereikt, stopt de uitvoering en wordt het beheer overgezet naar het foutopsporingsprogramma.

Als u het foutopsporingsprogramma wilt stoppen, voert u het script, de opdracht of de functie uit totdat het is voltooid. Of typ stop of t.

Opdrachten voor foutopsporing

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 voor hosttoepassingen voor informatie over het gebruik van het foutopsporingsprogramma in andere hosttoepassingen.

  • s, StepInto: voert de volgende instructie uit en stopt vervolgens.

  • v, StepOver: voert de volgende instructie uit, maar slaat functies en aanroepen over. De overgeslagen instructies worden uitgevoerd, maar niet doorlopen.

  • Ctrl+Break: (Alles onderbreken in ISE) Breekt in op een script dat wordt uitgevoerd in de PowerShell-console of Windows PowerShell ISE. Houd er rekening mee dat met Ctrl+Break in Windows PowerShell 2.0, 3.0 en 4.0 het programma wordt gesloten. Alles onderbreken werkt voor zowel lokale als externe interactief uitgevoerde scripts.

  • o, StepOut: stapt uit de huidige functie; één niveau omhoog indien genest. Als deze zich in de hoofdtekst bevindt, gaat deze verder naar het einde of het volgende onderbrekingspunt. De overgeslagen instructies worden uitgevoerd, maar niet doorlopen.

  • c, Continue: wordt uitgevoerd totdat het script is voltooid of totdat het volgende onderbrekingspunt is bereikt. De overgeslagen instructies worden uitgevoerd, maar niet 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, beginnend met het regelnummer dat is opgegeven door <m>.

  • l <m> <n>, List: geeft regels van het script weer <n> , 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 Debug-Job cmdlet uit te voeren, Exit wordt het foutopsporingsprogramma losgekoppeld en kan de taak worden uitgevoerd.

  • k, Get-PsCallStack: geeft de huidige aanroepstack weer.

  • <Enter>: Herhaalt de laatste opdracht als deze stap (s), StepOver (v) of List (l) was. Anders vertegenwoordigt een verzendactie.

  • ?, h: geeft de foutopsporingsopdracht Help weer.

Als u het foutopsporingsprogramma wilt afsluiten, kunt u Stoppen (q) gebruiken.

Vanaf PowerShell 5.0 kunt u de opdracht Afsluiten uitvoeren om een geneste foutopsporingssessie af te sluiten die u hebt gestart door of Debug-Runspaceuit te voerenDebug-Job.

Met behulp van deze opdrachten voor foutopsporing kunt u een script uitvoeren, stoppen op een punt van zorg, de waarden van variabelen en de status van het systeem onderzoeken en doorgaan met het uitvoeren van het script totdat u een probleem hebt vastgesteld.

OPMERKING: Als u naar een instructie stapt met een omleidingsoperator, zoals '>', wordt het foutopsporingsprogramma van PowerShell uitgevoerd op 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 van alle variabelen weergeven in het script dat wordt 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 voor in een interne pijplijn die het foutopsporingsprogramma gebruikt, niet de waarde van de variabele in het script.

Als u de waarde van deze variabelen wilt weergeven voor het script dat wordt 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 foutopsporingsprogrammaomgeving

Wanneer u een onderbrekingspunt bereikt, gaat u naar de foutopsporingsomgeving. De opdrachtprompt wordt gewijzigd zodat deze begint met "[DBG]:". Als u fouten in een werkstroom opspoort, is de prompt '[WFDBG]'. U kunt de prompt aanpassen.

Zie about_Prompts voor meer informatie over het aanpassen van de prompt.

Bovendien wordt in sommige hosttoepassingen, zoals de PowerShell-console (maar niet in Windows PowerShell Integrated Scripting Environment [ISE]), een geneste prompt voor foutopsporing geopend. U kunt de geneste prompt detecteren door de herhalende tekens groter dan (ASCII 62) die worden weergegeven bij de opdrachtprompt.

Hier volgt 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.

Daarnaast 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 het foutopsporingsprogramma bevindt.

Bijvoorbeeld:

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

U kunt de waarde van de $PSDebugContext variabele gebruiken in uw foutopsporing.

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

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

Foutopsporing en bereik

Inbreken in het foutopsporingsprogramma verandert niet het bereik waarin u werkt, maar wanneer u een onderbrekingspunt in een script bereikt, gaat u naar het scriptbereik. Het scriptbereik is een onderliggend bereik 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 cmdlets of Get-Variable .

Met de volgende opdracht worden bijvoorbeeld de variabelen in het lokale bereik (script) opgehaald:

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 het opsporen van fouten.

Foutopsporing op de opdrachtregel

Wanneer u een variabel onderbrekingspunt of een opdrachtonderbrekingspunt instelt, kunt u het onderbrekingspunt alleen instellen in een scriptbestand. Standaard wordt het onderbrekingspunt echter ingesteld op alles wat in de huidige sessie wordt uitgevoerd.

Als u bijvoorbeeld een onderbrekingspunt instelt voor de $name variabele, wordt het foutopsporingsprogramma onderbroken voor elke $name variabele in een script, opdracht, functie, script-cmdlet of expressie die u uitvoert totdat u het onderbrekingspunt uitschakelt of verwijdert.

Hiermee kunt u fouten opsporen in uw scripts in een meer realistische context waarin ze 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 ingesteld in scriptbestanden.

Foutopsporingswerkstromen

Het foutopsporingsprogramma van PowerShell 4.0 kan worden gebruikt om fouten op te sporen in PowerShell-werkstromen, in de PowerShell-console of in Windows PowerShell ISE. Er gelden enkele beperkingen bij het gebruik van 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.
  • Tabvoltooiing wanneer deze is gestopt in het foutopsporingsprogramma van de werkstroom 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 deze worden uitgevoerd als een taak (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 de foutopsporing in een werkstroom. Wanneer het foutopsporingsprogramma in de werkstroomfunctie stapt, wordt de foutopsporingsprompt gewijzigd 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 Beginsecties , Processen End , wordt het foutopsporingsprogramma afgebroken op de eerste regel van elke sectie.

Bijvoorbeeld:

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>

Foutopsporing voor externe scripts

Vanaf PowerShell 5.0 kunt u het Foutopsporingsprogramma van PowerShell 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 niet-verbonden sessie die wordt uitgevoerd op een externe computer en die momenteel een script uitvoert. Als het actieve script een onderbrekingspunt bereikt, start uw clientsessie automatisch het foutopsporingsprogramma.

Hier volgt 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, er twee aanwijzingen zijn: de naam van de computer waarop de sessie wordt uitgevoerd en de DBG-prompt waarmee u weet 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 interessant punt in het script, zoals een regel, opdracht, variabele of functie.

Begin met het maken van een regelonderbrekingspunt 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 afkort als:

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

De opdracht retourneert een regelonderbrekingspuntobject (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 een voorbeeld van de eerste regel van het script. Dit is een functiedeclaratie. De opdrachtprompt wordt ook gewijzigd om aan te geven dat het foutopsporingsprogramma controle heeft.

De voorbeeldregel bevat de naam van het script 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 (s) Stap om de eerste instructie in het script uit te voeren en een voorbeeld van de volgende instructie te bekijken. De volgende instructie gebruikt de $MyInvocation automatische 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 niet ingevuld, maar u kunt de waarde van de variabele controleren door de waarde ervan weer te geven. In dit geval is $nullde waarde .

DBG> $scriptname
# DBG>

Gebruik een andere step-opdracht (s) om de huidige instructie uit te voeren en een voorbeeld van de volgende instructie in het script te bekijken. Met de volgende instructie wordt de functie PsVersion aangeroepen.

DBG> s
test.ps1:12  psversion

Op dit moment wordt de $scriptName variabele ingevuld, maar controleert u 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' bij 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. Maar in dit geval gebruikt u een StepOut-opdracht (o). Hiermee wordt de uitvoering van de functie voltooid (tenzij er een onderbrekingspunt wordt bereikt) en wordt de volgende instructie in het script uitgevoerd.

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

Omdat we de laatste instructie in het script hebben, hebben de opdrachten Step, StepOut en Continue hetzelfde effect. Gebruik in dit geval StepOut (o).

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

Met de opdracht StepOut 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. Gebruik eerst de cmdlets en Remove-PSBreakpoint om het Get-PSBreakpoint huidige onderbrekingspunt te verwijderen. (Als u denkt dat u het onderbrekingspunt opnieuw kunt gebruiken, gebruikt u de Disable-PSBreakpoint cmdlet in plaats van Remove-PSBreakpoint.)

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

U kunt deze opdracht afkort 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 voor de $scriptname variabele.

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

U kunt de opdracht afkort 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 $scriptName variabele weergeven, namelijk $null.

DBG> $scriptName
# DBG>

Gebruik een stapopdracht (s) om de instructie uit te voeren waarmee de variabele wordt gevuld. Geef vervolgens de nieuwe waarde van de $scriptName variabele 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 van de functie PsVersion. Als u de functie wilt overslaan, maar deze toch wilt uitvoeren, gebruikt u de opdracht StepOver (v). Als u zich al in de functie bevindt wanneer u StepOver gebruikt, is deze niet effectief. De functie-aanroep wordt weergegeven, maar wordt niet uitgevoerd.

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

Met de opdracht StepOver wordt de functie uitgevoerd en wordt een voorbeeld van de volgende instructie in het script weergegeven, waarmee de laatste regel wordt afgedrukt.

Gebruik de opdracht Stoppen (t) om het foutopsporingsprogramma af te sluiten. De opdrachtprompt keert terug naar de standaardopdrachtprompt.

C:\ps-test>

Als u de onderbrekingspunten wilt verwijderen, gebruikt u de Get-PSBreakpoint cmdlets en Remove-PSBreakpoint .

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

Creatie een nieuw opdrachtonderbrekingspunt op de functie PsVersion.

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

U kunt deze opdracht afkort 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 functieaanroep. Op dit moment is de functie nog niet aangeroepen. Hiermee kunt u de parameter Action 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 diagnose- of beveiligingsscript.

Als u een actie wilt instellen, gebruikt u de opdracht Doorgaan (c) om het script af te sluiten en een Remove-PSBreakpoint opdracht om het huidige onderbrekingspunt te verwijderen. (Onderbrekingspunten 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 opdrachtonderbrekingspunt met een actie. Met de volgende opdracht wordt een opdrachtonderbrekingspunt ingesteld met een actie waarmee de waarde van de $scriptName variabele wordt vastgelegd wanneer de functie wordt aangeroepen. Omdat het trefwoord Einde niet wordt gebruikt in de actie, wordt de uitvoering niet gestopt. (Het backtick (') is het regelvervolgingsteken.)

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 Break in de actie stuurt het foutopsporingsprogramma om het onderbrekingspunt uit te voeren. U kunt ook het trefwoord Doorgaan gebruiken om het foutopsporingsprogramma uit te voeren zonder fouten te verbreken. Omdat het standaard trefwoord Doorgaan is, moet u Einde 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 foutopsporingsprogrammaopdracht (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 enkele van de vele manieren waarop u het Foutopsporingsprogramma van PowerShell kunt gebruiken.

Typ de volgende opdracht voor meer informatie over de foutopsporingsprogramma-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 en druk op F1 voor meer informatie.

  • De Set-PSDebug cmdlet biedt zeer eenvoudige functies voor foutopsporing voor scripts, waaronder stappen en tracering.

  • Gebruik de Set-StrictMode cmdlet om verwijzingen naar niet-geïnitialiseerde variabelen te detecteren, naar verwijzingen naar niet-bestaande eigenschappen van een object en naar ongeldige functiesyntaxis.

  • Voeg diagnostische instructies toe aan een script, zoals instructies die de waarde van variabelen weergeven, instructies die invoer van de opdrachtregel lezen of instructies die de huidige instructie rapporteren. Gebruik de cmdlets die de schrijfopdracht voor deze taak bevatten, zoals Write-Host, Write-Debug, Write-Warningen Write-Verbose.

ZIE OOK