Om fel söknings programAbout Debuggers

KORT BESKRIVNINGSHORT DESCRIPTION

Beskriver PowerShell-felsökaren.Describes the PowerShell debugger.

LÅNG BESKRIVNINGLONG DESCRIPTION

Fel sökning är en process för att undersöka ett skript när det körs för att identifiera och korrigera fel i skript instruktionerna.Debugging is the process of examining a script while it is running to identify and correct errors in the script instructions. PowerShell-felsökaren kan hjälpa dig att undersöka och identifiera fel och ineffektiv i skript, funktioner, kommandon, DSC-konfigurationer (Desired State Configuration) eller uttryck.The PowerShell debugger can help you examine and identify errors and inefficiencies in your scripts, functions, commands, PowerShell Desired State Configuration (DSC) configurations, or expressions.

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.Starting in PowerShell 5.0, the PowerShell debugger has been updated to debug scripts, functions, commands, configurations, or expressions that are running in either the console or Windows PowerShell ISE on remote computers. Du kan köra Enter-PSSession för att starta en interaktiv fjärran sluten PowerShell-session där du kan ange Bryt punkter och felsöka skriptfiler och kommandon på fjärrdatorn.You can run Enter-PSSession to start an interactive remote PowerShell session in which you can set breakpoints and debug script files and commands on the remote computer. 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.Enter-PSSession functionality has been updated to let you reconnect to and enter a disconnected session that is running a script or command on a remote computer. Om skriptet som körs träffar en Bryt punkt startar klient sessionen automatiskt fel söknings programmet.If the running script hits a breakpoint, your client session automatically starts the debugger. Om den frånkopplade sessionen som kör ett skript redan har nått en Bryt punkt och har stoppats vid Bryt punkten, Enter-PSSession startar automatiskt kommando rads fel söknings programmet när du återansluter till sessionen.If the disconnected session that is running a script has already hit a breakpoint, and is stopped at the breakpoint, Enter-PSSession automatically starts the command-line debugger, after you reconnect to the session.

Du kan använda funktionerna i PowerShell-felsökaren för att undersöka ett PowerShell-skript, funktion, kommando eller uttryck när den körs.You can use the features of the PowerShell debugger to examine a PowerShell script, function, command, or expression while it is running. PowerShell-felsökaren innehåller en uppsättning cmdletar som gör att du kan ange Bryt punkter, hantera Bryt punkter och Visa anrops stacken.The PowerShell debugger includes a set of cmdlets that let you set breakpoints, manage breakpoints, and view the call stack.

Fel söknings-cmdletarDebugger Cmdlets

PowerShell-felsökaren innehåller följande uppsättning cmdletar:The PowerShell debugger includes the following set of cmdlets:

  • Set-PSBreakpoint: Anger Bryt punkter för linjer, variabler och kommandon.Set-PSBreakpoint: Sets breakpoints on lines, variables, and commands.
  • Get-PSBreakpoint: Hämtar Bryt punkter i den aktuella sessionen.Get-PSBreakpoint: Gets breakpoints in the current session.
  • Disable-PSBreakpoint: Stänger av Bryt punkter i den aktuella sessionen.Disable-PSBreakpoint: Turns off breakpoints in the current session.
  • Enable-PSBreakpoint: Aktiverar Bryt punkter i den aktuella sessionen igen.Enable-PSBreakpoint: Re-enables breakpoints in the current session.
  • Remove-PSBreakpoint: Tar bort Bryt punkter från den aktuella sessionen.Remove-PSBreakpoint: Deletes breakpoints from the current session.
  • Get-PSCallStack: Visar den aktuella anrops stacken.Get-PSCallStack: Displays the current call stack.

Starta och stoppa fel söknings programmetStarting and Stopping the Debugger

Ange en eller flera Bryt punkter för att starta fel söknings programmet.To start the debugger, set one or more breakpoints. Kör sedan skriptet, kommandot eller funktionen som du vill felsöka.Then, run the script, command, or function that you want to debug.

När du når en Bryt punkt, stoppas körningen och kontroll sker över till fel söknings programmet.When you reach a breakpoint, execution stops, and control is turned over to the debugger.

Stoppa fel söknings programmet genom att köra skriptet, kommandot eller funktionen tills det är klart.To stop the debugger, run the script, command, or function until it is complete. Eller Skriv stop eller t .Or, type stop or t.

Fel söknings kommandonDebugger Commands

När du använder fel sökaren i PowerShell-konsolen, använder du följande kommandon för att kontrol lera körningen.When you use the debugger in the PowerShell console, use the following commands to control the execution. I Windows PowerShell ISE använder du kommandon på fel söknings menyn.In Windows PowerShell ISE, use commands on the Debug menu.

Obs! information om hur du använder fel sökaren i andra värd program finns i dokumentationen för värd programmet.Note: For information about how to use the debugger in other host applications, see the host application documentation.

  • s, StepInto : Kör nästa instruktion och stoppar sedan.s, StepInto: Executes the next statement and then stops.

  • v, StepOver : Kör nästa instruktion, men hoppar över funktioner och anrop.v, StepOver: Executes the next statement, but skips functions and invocations. De överhoppade instruktionerna körs, men är inte stegvisa.The skipped statements are executed, but not stepped through.

  • Ctrl+Break: (Break all i ISE) bryts i ett skript som körs antingen i PowerShell-konsolen eller Windows PowerShell ISE.Ctrl+Break: (Break All in ISE) Breaks into a running script within either the PowerShell console, or Windows PowerShell ISE. Observera att CTRL + Break i Windows PowerShell 2,0, 3,0 och 4,0 stänger programmet.Note that Ctrl+Break in Windows PowerShell 2.0, 3.0, and 4.0 closes the program. Bryt alla arbeten på både lokala och fjärranslutna skript som körs interaktivt.Break All works on both local and remote interactively-running scripts.

  • o, StepOut : Steg ut ur den aktuella funktionen, upp till en nivå om den är kapslad.o, StepOut: Steps out of the current function; up one level if nested. Om den finns i huvud texten fortsätter den till slutet eller nästa Bryt punkt.If in the main body, it continues to the end or the next breakpoint. De överhoppade instruktionerna körs, men är inte stegvisa.The skipped statements are executed, but not stepped through.

  • c, Continue : Fortsätter att köras tills skriptet har slutförts eller tills nästa Bryt punkt har nåtts.c, Continue: Continues to run until the script is complete or until the next breakpoint is reached. De överhoppade instruktionerna körs, men är inte stegvisa.The skipped statements are executed, but not stepped through.

  • l, List : Visar den del av skriptet som körs.l, List: Displays the part of the script that is executing. Som standard visas den aktuella raden, fem föregående rader och 10 efterföljande rader.By default, it displays the current line, five previous lines, and 10 subsequent lines. Tryck på RETUR för att fortsätta att lista skriptet.To continue listing the script, press ENTER.

  • l <m>, List : Visar 16 rader i skriptet som börjar med rad numret som anges av <m> .l <m>, List: Displays 16 lines of the script beginning with the line number specified by <m>.

  • l <m> <n>, List : Visar <n> rader i skriptet, som börjar med rad numret som anges av <m> .l <m> <n>, List: Displays <n> lines of the script, beginning with the line number specified by <m>.

  • q, Stop , Exit : Stoppar körningen av skriptet och avslutar fel söknings programmet.q, Stop, Exit: Stops executing the script, and exits the debugger. Om du felsöker ett jobb genom att köra Debug-Job cmdleten Exit kopplar kommandot av fel söknings programmet och gör att jobbet kan fortsätta att köras.If you are debugging a job by running the Debug-Job cmdlet, the Exit command detaches the debugger, and allows the job to continue running.

  • k, Get-PsCallStack : Visar den aktuella anrops stacken.k, Get-PsCallStack: Displays the current call stack.

  • <Enter>: Upprepar det senaste kommandot om det var steg, StepOver (v) eller List (l).<Enter>: Repeats the last command if it was Step (s), StepOver (v), or List (l). Annars representerar en skicka-åtgärd.Otherwise, represents a submit action.

  • ?, h : Visar hjälp om fel söknings kommandot.?, h: Displays the debugger command Help.

Om du vill avsluta fel söknings programmet kan du använda stop (q).To exit the debugger, you can use Stop (q).

Från och med PowerShell 5,0 kan du köra Exit-kommandot för att avsluta en kapslad felsökningssession som du startade genom att köra antingen Debug-Job eller Debug-Runspace .Starting in PowerShell 5.0, you can run the Exit command to exit a nested debugging session that you started by running either Debug-Job or Debug-Runspace.

Genom att använda de här fel söknings kommandona kan du köra ett skript, stoppa en viss angelägenhet, undersöka värdena för variabler och systemets tillstånd och fortsätta köra skriptet tills du har identifierat ett problem.By using these debugger commands, you can run a script, stop on a point of concern, examine the values of variables and the state of the system, and continue running the script until you have identified a problem.

Obs! Om du stegar i en instruktion med en omdirigerings Operator, t. ex. ">", PowerShell fel söknings stegen över alla återstående instruktioner i skriptet.NOTE: If you step into a statement with a redirection operator, such as ">", the PowerShell debugger steps over all remaining statements in the script.

Visar värdena för skript-variablerDisplaying the Values of script Variables

Medan du är i fel söknings programmet kan du också ange kommandon, Visa värdet för variabler, använda cmdlets och köra skript på kommando raden.While you are in the debugger, you can also enter commands, display the value of variables, use cmdlets, and run scripts at the command line.

Du kan visa det aktuella värdet för alla variabler i skriptet som felsöks, förutom följande automatiska variabler:You can display the current value of all variables in the script that is being debugged, except for the following automatic variables:

$_
$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 den variabeln för i en intern pipeline som fel sökaren använder, inte värdet för variabeln i skriptet.If you try to display the value of any of these variables, you get the value of that variable for in an internal pipeline the debugger uses, not the value of the variable in the script.

Om du vill visa värdet för de variabler som ska felsökas i skriptet, tilldelar du värdet för den automatiska variabeln till en ny variabel i skriptet.To display the value these variables for the script that is being debugged, in the script, assign the value of the automatic variable to a new variable. Sedan kan du Visa värdet för den nya variabeln.Then you can display the value of the new variable.

Exempel:For example,

$scriptArgs = $Args
$scriptArgs

I exemplet i det här avsnittet $MyInvocation omtilldelas värdet för variabeln enligt följande:In the example in this topic, the value of the $MyInvocation variable is reassigned as follows:

$scriptname = $MyInvocation.MyCommand.Path

Fel söknings miljönThe Debugger Environment

När du når en Bryt punkt anger du fel söknings miljön.When you reach a breakpoint, you enter the debugger environment. Kommando tolken ändras så att den börjar med "[DBG]:".The command prompt changes so that it begins with "[DBG]:".

Mer information om hur du anpassar meddelandet finns i about_Prompts.For more information about customizing the prompt, see about_Prompts.

I vissa värd program, t. ex. PowerShell-konsolen, (men inte i Windows PowerShell Integrated Scripting Environment [ISE]) öppnas en kapslad prompt för fel sökning.Also, in some host applications, such as the PowerShell console, (but not in Windows PowerShell Integrated Scripting Environment [ISE]), a nested prompt opens for debugging. Du kan identifiera den kapslade frågan genom att upprepa större än-tecken (ASCII 62) som visas i kommando tolken.You can detect the nested prompt by the repeating greater-than characters (ASCII 62) that appear at the command prompt.

Följande är till exempel standard fel söknings frågan i PowerShell-konsolen:For example, the following is the default debugging prompt in the PowerShell console:

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

Du kan hitta kapslings nivån genom att använda den $NestedPromptLevel automatiska variabeln.You can find the nesting level by using the $NestedPromptLevel automatic variable.

Dessutom definieras en automatisk variabel, $PSDebugContext , i det lokala omfånget.Additionally, an automatic variable, $PSDebugContext, is defined in the local scope. Du kan använda $PsDebugContext variabeln för att avgöra om du befinner dig i fel söknings programmet.You can use the presence of the $PsDebugContext variable to determine whether you are in the debugger.

Ett exempel:For example:

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

Du kan använda värdet för $PSDebugContext variabeln i fel sökningen.You can use the value of the $PSDebugContext variable in your debugging.

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

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

Fel sökning och omfångDebugging and Scope

Om du bryter ned i fel söknings programmet ändras inte omfattningen som du arbetar i, men när du når en Bryt punkt i ett skript, flyttas du till skript omfånget.Breaking into the debugger does not change the scope in which you are operating, but when you reach a breakpoint in a script, you move into the script scope. Skript omfånget är underordnat det omfång i vilket du körde fel söknings programmet.The script scope is a child of the scope in which you ran the debugger.

Om du vill hitta variabler och alias som har definierats i skript omfånget använder du omfattnings parametern Get-Alias för Get-Variable cmdletarna eller.To find the variables and aliases that are defined in the script scope, use the Scope parameter of the Get-Alias or Get-Variable cmdlets.

Följande kommando hämtar till exempel variablerna i den lokala (skript) omfattningen:For example, the following command gets the variables in the local (script) scope:

Get-Variable -scope 0

Du kan förkorta kommandot som:You can abbreviate the command as:

gv -s 0

Det här är ett användbart sätt att bara se de variabler som du har definierat i skriptet och som du definierade vid fel sökning.This is a useful way to see only the variables that you defined in the script and that you defined while debugging.

Fel sökning på kommando radenDebugging at the Command Line

När du anger en variabel Bryt punkt eller en kommando Bryt punkt kan du bara ange Bryt punkten i en skript fil.When you set a variable breakpoint or a command breakpoint, you can set the breakpoint only in a script file. Som standard anges Bryt punkten för allt som körs i den aktuella sessionen.However, by default, the breakpoint is set on anything that runs in the current session.

Om du till exempel ställer in en Bryt punkt på $name variabeln, bryts fel söknings verktyget på valfri $name variabel i skript, kommando, funktion, skript-cmdlet eller uttryck som du kör tills du inaktiverar eller tar bort Bryt punkten.For example, if you set a breakpoint on the $name variable, the debugger breaks on any $name variable in any script, command, function, script cmdlet or expression that you run until you disable or remove the breakpoint.

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.This allows you to debug your scripts in a more realistic context in which they might be affected by functions, variables, and other scripts in the session and in the user's profile.

Rad Bryt punkter är specifika för skriptfiler, så de anges bara i skriptfiler.Line breakpoints are specific to script files, so they are set only in script files.

Fel söknings funktionerDebugging Functions

När du anger en Bryt punkt för en funktion som har Begin , Process , och End avsnitt, bryts fel söknings verktyget på den första raden i varje avsnitt.When you set a breakpoint on a function that has Begin, Process, and End sections, the debugger breaks at the first line of each section.

Ett exempel:For example:

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ärrskriptDebugging Remote Scripts

Från och med PowerShell 5,0 kan du köra PowerShell-felsökning i en fjärrsession, antingen i-konsolen eller Windows PowerShell ISE.Starting in PowerShell 5.0, you can run the PowerShell debugger in a remote session, in either the console, or 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 kör ett skript.Enter-PSSession functionality has been updated to let you reconnect to and enter a disconnected session that is running on a remote computer, and currently running a script. Om skriptet som körs träffar en Bryt punkt startar klient sessionen automatiskt fel söknings programmet.If the running script hits a breakpoint, your client session automatically starts the debugger.

Följande är ett exempel som visar hur det fungerar, med Bryt punkter som anges i ett skript på rad 6, 11, 22 och 25.The following is an example that shows how this works, with breakpoints set in a script at lines 6, 11, 22, and 25. Observera att i exemplet, när fel söknings programmet startar, finns det två identifierande prompter: namnet på den dator där sessionen körs och DBG-prompten där du vet att du är i fel söknings läge.Note that in the example, when the debugger starts, there are two identifying prompts: the name of the computer on which the session is running, and the DBG prompt that lets you know you are in debugging mode.

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>

ExempelExamples

Det här test skriptet identifierar operativ systemets version och visar ett system-lämpligt meddelande.This test script detects the version of the operating system and displays a system-appropriate message. Den innehåller en funktion, ett funktions anrop och en variabel.It includes a function, a function call, and a variable.

Följande kommando visar innehållet i test skript filen:The following command displays the contents of the test script file:

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 Bryt punkt i en orienterings punkt i skriptet, till exempel en linje, ett kommando, en variabel eller en funktion.To start, set a breakpoint at a point of interest in the script, such as a line, command, variable, or function.

Börja med att skapa en rad Bryt punkt på den första raden i Test.ps1-skriptet i den aktuella katalogen.Start by creating a line breakpoint on the first line of the Test.ps1 script in the current directory.

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

Du kan förkorta det här kommandot som:You can abbreviate this command as:

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

Kommandot returnerar ett rad brytnings objekt ( system. Management. Automation. LineBreakpoint ).The command returns a line-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

Starta nu skriptet.Now, start the script.

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

När skriptet når den första Bryt punkten, anger Bryt punkts meddelandet att fel söknings programmet är aktivt.When the script reaches the first breakpoint, the breakpoint message indicates that the debugger is active. Den beskriver Bryt punkten och för hands versionerna av den första raden i skriptet, som är en funktions deklaration.It describes the breakpoint and previews the first line of the script, which is a function declaration. Kommando tolken ändras också för att indikera att fel söknings programmet har kontroll.The command prompt also changes to indicate that the debugger has control.

För hands versions raden ingår skript namnet och rad numret för det förvisade kommandot.The preview line includes the script name and the line number of the previewed command.

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 steg-kommandona för att köra den första instruktionen i skriptet och för att förhandsgranska nästa instruktion.Use the Step command (s) to execute the first statement in the script and to preview the next statement. I nästa instruktion används den $MyInvocation automatiska variabeln för att ange värdet för $scriptName variabeln till sökvägen och fil namnet för skript filen.The next statement uses the $MyInvocation automatic variable to set the value of the $scriptName variable to the path and file name of the script file.

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

$scriptNameVariabeln är nu inte ifylld, men du kan kontrol lera värdet för variabeln genom att visa dess värde.At this point, the $scriptName variable is not populated, but you can verify the value of the variable by displaying its value. I det här fallet är värdet $null .In this case, the value is $null.

DBG> $scriptname
# DBG>

Använd ett annat steg för att köra den aktuella instruktionen och för att förhandsgranska nästa instruktion i skriptet.Use another Step command (s) to execute the current statement and to preview the next statement in the script. Next-instruktionen anropar funktionen PsVersion.The next statement calls the PsVersion function.

DBG> s
test.ps1:12  psversion

I det här läget $scriptName fylls variabeln i, men du verifierar värdet för variabeln genom att visa dess värde.At this point, the $scriptName variable is populated, but you verify the value of the variable by displaying its value. I det här fallet anges värdet för skript Sök vägen.In this case, the value is set to the script path.

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

Använd ett annat steg-kommando för att köra funktions anropet.Use another Step command to execute the function call. Tryck på RETUR eller skriv "s" för steg.Press ENTER, or type "s" for Step.

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

Fel söknings meddelandet innehåller en förhands granskning av instruktionen i funktionen.The debug message includes a preview of the statement in the function. Om du vill köra den här instruktionen och för att förhandsgranska nästa instruktion i funktionen kan du använda ett Step kommando.To execute this statement and to preview the next statement in the function, you can use a Step command. Men i det här fallet använder du ett utgångs kommando (o).But, in this case, use a StepOut command (o). Körningen av funktionen slutförs (såvida den inte når en Bryt punkt) och steg till nästa instruktion i skriptet.It completes the execution of the function (unless it reaches a breakpoint) and steps to the next statement in the script.

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 steget, steget och kommandot Continue samma resultat.Because we are on the last statement in the script, the Step, StepOut, and Continue commands have the same effect. I det här fallet använder du stega (o).In this case, use StepOut (o).

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

Kommandot stega kör det sista kommandot.The StepOut command executes the last command. Standard kommando tolken anger att fel söknings programmet har avslutat och returnerat kontroll till kommando processorn.The standard command prompt indicates that the debugger has exited and returned control to the command processor.

Kör nu fel söknings programmet igen.Now, run the debugger again. Ta först bort den aktuella Bryt punkten genom att använda Get-PsBreakpoint Remove-PsBreakpoint cmdletarna och.First, to delete the current breakpoint, use the Get-PsBreakpoint and Remove-PsBreakpoint cmdlets. (Om du tror att du kan återanvända Bryt punkten använder du Disable-PsBreakpoint cmdleten i stället för Remove-PsBreakpoint .)(If you think you might reuse the breakpoint, use the Disable-PsBreakpoint cmdlet instead of Remove-PsBreakpoint.)

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

Du kan förkorta det här kommandot som:You can abbreviate this command as:

PS C:\ps-test> gbp | rbp

Eller kör kommandot genom att skriva en funktion, till exempel följande funktion:Or, run the command by writing a function, such as the following function:

function delbr { gbp | rbp }

Nu ska du skapa en Bryt punkt för $scriptname variabeln.Now, create a breakpoint on the $scriptname variable.

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

Du kan förkorta kommandot som:You can abbreviate the command as:

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

Starta nu skriptet.Now, start the script. Skriptet når den variabla Bryt punkten.The script reaches the variable breakpoint. Standard läget är Write, så körningen stoppas precis innan instruktionen som ändrar värdet för variabeln.The default mode is Write, so execution stops just before the statement that changes the value of the variable.

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 .Display the current value of the $scriptName variable, which is $null.

DBG> $scriptName
# DBG>

Använd ett eller flera steg för att köra instruktionen som fyller på variabeln.Use a Step command (s) to execute the statement that populates the variable. Sedan visar du det nya värdet för $scriptName variabeln.Then, display the new value of the $scriptName variable.

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

Next-instruktionen är ett anrop till funktionen PsVersion.The next statement is a call to the PsVersion function. Om du vill hoppa över funktionen men ändå köra den, använder du ett StepOver-kommando (v).To skip the function but still execute it, use a StepOver command (v). Om du redan har använt funktionen StepOver är det inte effektivt.If you are already in the function when you use StepOver, it is not effective. Funktions anropet visas, men det körs inte.The function call is displayed, but it is not executed.

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ör hands Grans kar nästa instruktion i skriptet som skriver ut den sista raden.The StepOver command executes the function, and it previews the next statement in the script, which prints the final line.

Använd ett stopp kommando (t) för att avsluta fel söknings programmet.Use a Stop command (t) to exit the debugger. Kommando tolken återgår till standard kommando tolken.The command prompt reverts to the standard command prompt.

C:\ps-test>

Om du vill ta bort Bryt punkterna använder Get-PsBreakpoint du Remove-PsBreakpoint cmdletarna och.To delete the breakpoints, use the Get-PsBreakpoint and Remove-PsBreakpoint cmdlets.

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

Skapa en ny kommando Bryt punkt för funktionen PsVersion.Create a new command breakpoint on the PsVersion function.

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

Du kan förkorta det här kommandot för att:You can abbreviate this command to:

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

Kör nu skriptet.Now, run the script.

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

test.ps1:12  psversion
# DBG>

Skriptet når Bryt punkten vid funktions anropet.The script reaches the breakpoint at the function call. I det här läget har funktionen inte anropats än.At this point, the function has not yet been called. Det ger dig möjlighet att använda åtgärds parametern för Set-PSBreakpoint för att ange villkor för körning av Bryt punkten eller för att utföra förberedande eller diagnostiska uppgifter, till exempel starta en logg eller anropa ett diagnostik-eller säkerhets skript.This gives you the opportunity to use the Action parameter of Set-PSBreakpoint to set conditions for the execution of the breakpoint or to perform preparatory or diagnostic tasks, such as starting a log or invoking a diagnostic or security script.

Ange en åtgärd genom att använda ett Continue-kommando (c) för att avsluta skriptet och ett Remove-PsBreakpoint kommando för att ta bort den aktuella Bryt punkten.To set an action, use a Continue command (c) to exit the script, and a Remove-PsBreakpoint command to delete the current breakpoint. (Bryt punkter är skrivskyddade, så du kan inte lägga till en åtgärd i den aktuella Bryt punkten.)(Breakpoints are read-only, so you cannot add an action to the current breakpoint.)

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>

Nu skapar du en ny kommando Bryt punkt med en åtgärd.Now, create a new command breakpoint with an action. Följande kommando anger en kommando Bryt punkt med en åtgärd som loggar värdet för $scriptName variabeln när funktionen anropas.The following command sets a command breakpoint with an action that logs the value of the $scriptName variable when the function is called. Eftersom Break-nyckelordet inte används i åtgärden stoppas inte körningen.Because the Break keyword is not used in the action, execution does not stop. ("Bakticket (") är ett linje fortsättnings kort.)(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 Bryt punkten.You can also add actions that set conditions for the breakpoint. I följande kommando körs kommando Bryt punkten endast om körnings principen är inställd på RemoteSigned, den mest restriktiva principen som fortfarande tillåter att du kör skript.In the following command, the command breakpoint is executed only if the execution policy is set to RemoteSigned, the most restrictive policy that still permits you to run scripts. ("Bakticket (") är det fortsättnings tecknen.)(The backtick (`) is the continuation character.)

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

Nyckelordet Break i åtgärden styr fel söknings verktyget att köra Bryt punkten.The Break keyword in the action directs the debugger to execute the breakpoint. Du kan också använda nyckelordet Continue för att direkt köra fel söknings programmet utan att behöva bryta.You can also use the Continue keyword to direct the debugger to execute without breaking. Eftersom nyckelordet default är Continue måste du ange Break för att stoppa körningen.Because the default keyword is Continue, you must specify Break to stop execution.

Kör nu skriptet.Now, run the script.

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

test.ps1:12  psversion

Eftersom körnings principen är inställd på RemoteSigned , stoppas körningen vid funktions anropet.Because the execution policy is set to RemoteSigned , execution stops at the function call.

I det här läget kanske du vill kontrol lera anrops stacken.At this point, you might want to check the call stack. Använd Get-PsCallStack cmdleten eller Get-PsCallStack fel söknings kommandot (k).Use the Get-PsCallStack cmdlet or the Get-PsCallStack debugger command (k). Följande kommando hämtar den aktuella anrops stacken.The following command gets the current call stack.

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

Det här exemplet visar bara några av många sätt att använda PowerShell-felsökaren.This example demonstrates just a few of the many ways to use the PowerShell debugger.

Om du vill ha mer information om fel söknings-cmdletar skriver du följande kommando:For more information about the debugger cmdlets, type the following command:

help <cmdlet-name> -full

Skriv till exempel:For example, type:

help Set-PSBreakpoint -full

Andra fel söknings funktioner i PowerShellOther Debugging Features in 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.In addition to the PowerShell debugger, PowerShell includes several other features that you can use to debug scripts and functions.

  • Windows PowerShell ISE innehåller en interaktiv grafisk fel sökare.Windows PowerShell ISE includes an interactive graphical debugger. Om du vill ha mer information startar du Windows PowerShell ISE och trycker på F1.For more information, start Windows PowerShell ISE and press F1.

  • Set-PSDebugCmdleten erbjuder mycket grundläggande skript fel söknings funktioner, inklusive steging och spårning.The Set-PSDebug cmdlet offers very basic script debugging features, including stepping and tracing.

  • Använd Set-StrictMode cmdleten för att identifiera referenser till oinitierade variabler, referera till obefintliga egenskaper för ett objekt och för att visa syntaxen som inte är giltig.Use the Set-StrictMode cmdlet to detect references to uninitialized variables, to references to non-existent properties of an object, and to function syntax that is not valid.

  • Lägg till diagnostiska uttryck i ett skript, till exempel instruktioner som visar värdet för variabler, instruktioner som läser ininformation från kommando raden eller instruktioner som rapporterar den aktuella instruktionen.Add diagnostic statements to a script, such as statements that display the value of variables, statements that read input from the command line, or statements that report the current instruction. Använd de cmdlets som innehåller Skriv verbet för uppgiften, till exempel, Write-Host , Write-Debug Write-Warning och Write-Verbose .Use the cmdlets that contain the Write verb for this task, such as Write-Host, Write-Debug, Write-Warning, and Write-Verbose.

SE ÄVENSEE ALSO