about_Debuggers
Mis à jour: mai 2014
S'applique à: Windows PowerShell 2.0, Windows PowerShell 3.0, Windows PowerShell 4.0, Windows PowerShell 5.0
Insérez l'introduction ici.
RUBRIQUE
about_Debuggers
DESCRIPTION COURTE
Décrit le débogueur Windows PowerShell®.
DESCRIPTION DÉTAILLÉE
Le débogage est le processus qui consiste à examiner un script en cours d’exécution pour identifier et corriger les erreurs dans les instructions de script. Le débogueur Windows PowerShell est conçu pour vous aider à examiner et identifier les erreurs et les inefficacités dans vos scripts, fonctions, commandes, workflows Windows PowerShell ou expressions.
Dans Windows PowerShell 4.0, le débogueur Windows PowerShell a été mis à jour pour déboguer des scripts, fonctions, workflows, commandes ou expressions qui sont exécutés dans la console Windows PowerShell (pas dans l’environnement ISE) sur des ordinateurs distants. Vous pouvez exécuter Enter-PSSession pour démarrer une session PowerShell à distance interactive dans laquelle vous pouvez définir des points d’arrêt et déboguer des fichiers de script et des commandes sur l’ordinateur distant. La fonctionnalité Enter-PSSession a été mise à jour pour vous permettre de vous reconnecter et d’accéder à une session déconnectée qui exécute un script ou une commande sur un ordinateur distant. Si le script en cours d’exécution rencontre un point d’arrêt, votre session client démarre automatiquement le débogueur. Si la session déconnectée qui exécute un script a déjà atteint un point d’arrêt et s’arrête à ce niveau, Enter-PSSession démarre automatiquement le débogueur en ligne de commande, une fois que vous vous êtes reconnecté à la session.
Le débogueur Windows PowerShell 4.0 peut également être utilisé pour déboguer des workflows Windows PowerShell, dans la console Windows PowerShell ou dans l’environnement ISE de Windows PowerShell.
Vous pouvez utiliser les fonctionnalités du débogueur Windows PowerShell pour examiner un script, une fonction, une commande, un workflow ou une expression Windows PowerShell en cours d’exécution. Le débogueur Windows PowerShell inclut un ensemble d’applets de commande qui vous permettent de définir des points d’arrêt, de gérer les points d’arrêt et d’afficher la pile des appels.
APPLETS DE COMMANDE DU DÉBOGUEUR
Le débogueur Windows PowerShell comprend l’ensemble suivant d’applets de commande :
Set-PsBreakpoint: Sets breakpoints on lines, variables, and
commands.
Get-PsBreakpoint: Gets breakpoints in the current session.
Disable-PsBreakpoint: Turns off breakpoints in the current session.
Enable-PsBreakpoint: Re-enables breakpoints in the current session.
Remove-PsBreakpoint: Deletes breakpoints from the current session.
Get-PsCallStack: Displays the current call stack.
DÉMARRAGE ET ARRÊT DU DÉBOGUEUR
Pour démarrer le débogueur, définissez un ou plusieurs points d’arrêt. Ensuite, exécutez le script, la commande ou la fonction que vous souhaitez déboguer.
Quand vous atteignez un point d’arrêt, l’exécution s’arrête et le contrôle est délégué au débogueur.
Pour arrêter le débogueur, exécutez le script, la commande ou la fonction jusqu’à la fin. Vous pouvez également taper « stop » ou « t ».
COMMANDES DU DÉBOGUEUR
Quand vous utilisez le débogueur dans la console Windows PowerShell, utilisez les commandes suivantes pour contrôler l’exécution. Dans l’environnement ISE de Windows PowerShell, utilisez les commandes dans le menu Déboguer.
Remarque : pour plus d’informations sur l’utilisation du débogueur dans d’autres applications hôtes, consultez la documentation de l’application hôte.
s, Step-into Executes the next statement and then stops.
v, Step-over Executes the next statement, but skips functions
and invocations. The skipped statements are
executed, but not stepped through.
o, Step-out Steps out of the current function; up one level
if nested. If in the main body, it continues to
the end or the next breakpoint. The skipped
statements are executed, but not stepped through.
c, Continue Continues to run until the script is complete or
until the next breakpoint is reached. The skipped
statements are executed, but not stepped through.
l, List Displays the part of the script that is executing.
By default, it displays the current line, five
previous lines, and 10 subsequent lines. To continue
listing the script, press ENTER.
l <m>, List Displays 16 lines of the script beginning with the
line number specified by <m>.
l <m> <n>, List Displays <n> lines of the script, beginning with the
line number specified by <m>.
q, Stop Stops executing the script, and exits the debugger.
k, Get-PsCallStack Displays the current call stack.
<Enter> Repeats the last command if it was Step (s),
Step-over (v), or List (l). Otherwise, represents a
submit action.
?, h Displays the debugger command Help.
To exit the debugger, use Stop (q).
À l’aide de ces commandes de débogueur, vous pouvez exécuter un script, vous arrêter sur un sujet de préoccupation, examiner les valeurs des variables ainsi que l’état du système et continuer à exécuter le script jusqu’à ce que vous ayez identifié un problème.
REMARQUE :
Si vous effectuez un pas à pas détaillé dans une instruction avec un opérateur de redirection, par exemple « > », le débogueur Windows PowerShell effectue un pas à pas principal dans toutes les instructions restantes du script.
AFFICHAGE DES VALEURS DES VARIABLES DE SCRIPT
Pendant que vous êtes dans le débogueur, vous pouvez également entrer des commandes, afficher la valeur des variables, utiliser des applets de commande et exécuter des scripts à la ligne de commande.
Vous pouvez afficher la valeur actuelle de toutes les variables dans le script en cours de débogage, à l’exception des variables automatiques suivantes :
$_
$Args
$Input
$MyInvocation
$PSBoundParameters
Si vous essayez d’afficher la valeur de l’une de ces variables, vous obtenez la valeur de cette variable dans un pipeline interne utilisé par le débogueur, et non la valeur de la variable dans le script.
Pour afficher la valeur de ces variables pour le script en cours de débogage, dans le script, affectez la valeur de la variable automatique à une nouvelle variable. Vous pouvez ensuite afficher la valeur de la nouvelle variable.
Par exemple,
$scriptArgs = $Args
$scriptArgs
Dans l’exemple de cette rubrique, la valeur de la variable $MyInvocation est réaffectée comme suit :
$scriptname = $MyInvocation.MyCommand.Path
ENVIRONNEMENT DU DÉBOGUEUR
Quand vous atteignez un point d’arrêt, vous entrez dans l’environnement du débogueur. L’invite de commandes est modifiée pour commencer par « [DBG]: ». Si vous déboguez un workflow, l’invite est « [WFDBG] ». Vous pouvez personnaliser l’invite de commandes.
En outre, dans certaines applications hôtes, telles que la console Windows PowerShell, (mais pas dans l’environnement d’écriture de scripts intégré [ISE] de Windows PowerShell), une invite imbriquée s’ouvre pour le débogage. Vous pouvez détecter l’invite imbriquée par les signes supérieur (ASCII 62) répétés qui s’affichent à l’invite de commandes.
Par exemple, voici l’invite de débogage par défaut dans la console Windows PowerShell :
[DBG]: PS (get-location)>>>
Vous pouvez trouver le niveau d’imbrication à l’aide de la variable automatique $NestedPromptLevel.
En outre, une variable automatique, $PSDebugContext, est définie dans l’étendue locale. Vous pouvez utiliser la présence de la variable $PsDebugContext pour déterminer si vous êtes dans le débogueur.
Exemple :
if ($psdebugcontext) {"Debugging"} else {"Not Debugging"}
Vous pouvez utiliser la valeur de la variable $PSDebugContext dans le débogage.
[DBG]: PS>>> $psdebugcontext.invocationinfo
Name CommandLineParameters UnboundArguments Location
---- --------------------- ---------------- --------
= {} {} C:\ps-test\vote.ps1 (1)
DÉBOGAGE ET ÉTENDUE
L’arrêt dans le débogueur ne modifie pas l’étendue dans laquelle vous travaillez mais, quand vous atteignez un point d’arrêt dans un script, vous passez dans l’étendue du script. L’étendue du script est un enfant de l’étendue dans laquelle vous avez exécuté le débogueur.
Pour rechercher les variables et les alias définis dans l’étendue du script, utilisez le paramètre Scope des applets de commande Get-Alias ou Get-Variable.
Par exemple, la commande suivante obtient les variables dans l’étendue locale (script) :
get-variable -scope 0
Vous pouvez abréger la commande comme suit :
gv -s 0
Il s’agit d’un moyen utile d’afficher uniquement les variables que vous avez définies dans le script et pendant le débogage.
DÉBOGAGE À LA LIGNE DE COMMANDE
Quand vous définissez un point d’arrêt de variable ou de commande, vous pouvez définir le point d’arrêt uniquement dans un fichier de script. Toutefois, par défaut, le point d’arrêt est défini sur tout ce qui s’exécute dans la session active.
Par exemple, si vous définissez un point d’arrêt sur la variable $name, le débogueur s’arrête sur toute variable $name dans n’importe quel script, commande, fonction, applet de commande de script ou expression que vous exécutez jusqu’à ce que vous désactiviez ou supprimiez le point d’arrêt.
Cela vous permet de déboguer vos scripts dans un contexte plus réaliste dans lequel ils peuvent être affectés par les fonctions, variables et autres scripts dans la session et dans le profil de l’utilisateur.
Les points d’arrêt de ligne étant spécifiques aux fichiers de script, ils sont définis uniquement dans les fichiers de script.
DÉBOGAGE DE WORKFLOWS
Le débogueur Windows PowerShell 4.0 peut être utilisé pour déboguer des workflows Windows PowerShell, dans la console Windows PowerShell ou dans l’environnement ISE de Windows PowerShell. Il existe certaines limitations liées à l’utilisation du débogueur Windows PowerShell pour déboguer les workflows.
-- You can view workflow variables while you are in the debugger, but
setting workflow variables from within the debugger is not supported.
-- Tab completion when stopped in the workflow debugger is not
available.
-- Workflow debugging works only with synchronous running of workflows from
a Windows PowerShell script. You cannot debug workflows if they are
running as a job (with the –AsJob parameter).
-- Other nested debugging scenarios--such as a workflow calling another
workflow, or a workflow calling a script--are not implemented.
L’exemple suivant illustre le débogage d’un workflow. Notez que, quand le débogueur effectue un pas à pas détaillé dans la fonction de workflow, l’invite de commandes de débogueur devient [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:"
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[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
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[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:"
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[WFDBG:localhost]: PS C:\>> stepOut
Get PowerShell process:
Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName PSComputerName
------- ------ ----- ----- ----- ------ -- ----------- --------------
433 35 106688 128392 726 2.67 7124 powershell localhost
499 44 134244 172096 787 2.79 7452 powershell localhost
Workflow function complete.
FONCTIONS DE DÉBOGAGE
Quand vous définissez un point d’arrêt sur une fonction qui possède des sections Begin, Process et End, le débogueur s’arrête à la première ligne de chaque section.
Exemple :
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>
DÉBOGAGE DE SCRIPTS DISTANTS
Dans Windows PowerShell 4.0, vous pouvez exécuter le débogueur Windows PowerShell dans une session à distance, dans la console Windows PowerShell 4.0. La fonctionnalité Enter-PSSession a été mise à jour pour vous permettre de vous reconnecter et d’accéder à une session déconnectée qui est exécutée sur un ordinateur distant, et qui exécute actuellement un script. Si le script en cours d’exécution rencontre un point d’arrêt, votre session client démarre automatiquement le débogueur. Voici un exemple qui montre comment cela fonctionne, avec des points d’arrêt définis dans un script aux lignes 6, 11, 22 et 25. Notez que, dans l’exemple, quand le débogueur démarre, il existe deux invites d’identification : le nom de l’ordinateur sur lequel la session est en cours d’exécution et l’invite DBG qui vous permet de savoir que vous êtes en mode débogage.
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>
EXEMPLES
Ce script de test détecte la version du système d’exploitation et affiche un message approprié au système. Il inclut une fonction, un appel de fonction et une variable.
La commande suivante affiche le contenu du fichier de script de test :
c:>\PS-test> get-content test.ps1
function psversion {
"Windows PowerShell " + $psversiontable.psversion
if ($psversiontable.psversion.major -lt 2) {
"Upgrade to Windows PowerShell 2.0!"
}
else {
"Have you run a background job today (start-job)?"
}
}
$scriptname = $MyInvocation.MyCommand.Path
psversion
"Done $scriptname."
Pour commencer, définissez un point d’arrêt sur un point d’intérêt dans le script, par exemple une ligne, une commande, une variable ou une fonction.
Commencez par créer un point d’arrêt de ligne sur la première ligne du script Test.ps1 dans le répertoire actif.
PS C:\ps-test> set-psbreakpoint -line 1 -script test.ps1
Vous pouvez abréger cette commande :
PS C:\ps-test> spb 1 -s test.ps1
La commande retourne un objet de point d’arrêt de ligne (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
Maintenant, démarrez le script.
PS C:\ps-test> .\test.ps1
Quand le script atteint le premier point d’arrêt, le message de point d’arrêt indique que le débogueur est actif. Il décrit le point d’arrêt et affiche un aperçu de la première ligne du script, qui est une déclaration de fonction. L’invite de commandes change également pour indiquer que le débogueur a le contrôle.
La ligne d’aperçu inclut le nom du script et le numéro de ligne de la commande qui fait l’objet de l’aperçu.
Entering debug mode. Use h or ? for help.
Hit Line breakpoint on 'C:\ps-test\test.ps1:1'
test.ps1:1 function psversion {
DBG>
Utilisez la ou les commandes Step pour exécuter la première instruction dans le script et afficher un aperçu de l’instruction suivante. L’instruction suivante utilise la variable automatique $MyInvocation pour définir la valeur de la variable $ScriptName sur le chemin d’accès et le nom du fichier de script.
DBG> s
test.ps1:11 $scriptname = $MyInvocation.MyCommand.Path
À ce stade, la variable $ScriptName n’est pas remplie, mais vous pouvez vérifier la valeur de la variable en affichant sa valeur. Dans ce cas, la valeur est $null.
DBG> $scriptname
DBG>
Utilisez une autre ou d’autres commandes Step pour exécuter l’instruction actuelle et afficher un aperçu de l’instruction suivante dans le script. L’instruction suivante appelle la fonction PsVersion.
DBG> s
test.ps1:12 psversion
À ce stade, la variable $ScriptName est remplie, mais vous vérifiez la valeur de la variable en affichant sa valeur. Dans ce cas, la valeur est définie sur le chemin d’accès du script.
DBG> $scriptname
C:\ps-test\test.ps1
Utilisez une autre commande Step pour exécuter l’appel de fonction. Appuyez sur Entrée, ou tapez « s » pour Step.
DBG> s
test.ps1:2 "Windows PowerShell " + $psversiontable.psversion
Le message de débogage inclut un aperçu de l’instruction dans la fonction. Pour exécuter cette instruction et afficher un aperçu de l’instruction suivante dans la fonction, vous pouvez utiliser une commande Step. Toutefois, dans ce cas, utilisez une commande Step-Out (o). Elle termine l’exécution de la fonction (à moins qu’elle n’atteigne un point d’arrêt) et passe à l’instruction suivante dans le script.
DBG> o
Windows PowerShell 2.0
Have you run a background job today (start-job)?
test.ps1:13 "Done $scriptname"
Comme nous nous trouvons sur la dernière instruction dans le script, les commandes Step, Step-Out et Continue ont le même effet. Dans ce cas, utilisez Step-Out (o).
Done C:\ps-test\test.ps1
PS C:\ps-test>
La commande Step-Out exécute la dernière commande. L’invite de commandes standard indique que le débogueur s’est arrêté et a rendu le contrôle à l’interpréteur de commandes.
Maintenant, exécutez de nouveau le débogueur. Tout d’abord, pour supprimer le point d’arrêt actuel, utilisez les applets de commande Get-PsBreakpoint et Remove-PsBreakpoint. (Si vous pensez que vous pouvez réutiliser le point d’arrêt, utilisez l’applet de commande Disable-PsBreakpoint au lieu de Remove-PsBreakpoint.)
PS C:\ps-test> Get-PsBreakpoint | Remove-PSBreakpoint
Vous pouvez abréger cette commande :
PS C:\ps-test> gbp | rbp
Vous pouvez également exécuter la commande en écrivant une fonction, comme la fonction suivante :
function delbr { gbp | rbp }
À présent, créez un point d’arrêt sur la variable $scriptname.
PS C:\ps-test> set-psbreakpoint -variable scriptname -script test.ps1
Vous pouvez abréger la commande comme suit :
PS C:\ps-test> sbp -v scriptname -s test.ps1
Maintenant, démarrez le script. Le script atteint le point d’arrêt de la variable. Le mode par défaut étant écriture, l’exécution s’arrête juste avant l’instruction qui modifie la valeur de la 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>
Affichez la valeur actuelle de la variable $scriptname, qui est $null.
DBG> $scriptname
DBG>
Utilisez une ou des commandes Step pour exécuter l’instruction qui remplit la variable. Ensuite, affichez la nouvelle valeur de la variable $scriptname.
DBG> $scriptname
C:\ps-test\test.ps1
Utilisez une ou des commandes Step pour afficher un aperçu de l’instruction suivante dans le script.
DBG> s
test.ps1:12 psversion
L’instruction suivante est un appel à la fonction PsVersion. Pour ignorer la fonction mais cependant l’exécuter, utilisez une commande Step-Over (v). Si vous êtes déjà dans la fonction quand vous utilisez Step-Over, elle n’est pas effective. L’appel de fonction est affiché, mais il n’est pas exécuté.
DBG> v
Windows PowerShell 2.0
Have you run a background job today (start-job)?
test.ps1:13 "Done $scriptname"
La commande Step-Over exécute la fonction et affiche un aperçu de l’instruction suivante dans le script qui imprime la dernière ligne.
Utilisez une commande Stop (t) pour quitter le débogueur. L’invite de commandes redevient l’invite de commandes standard.
C:\ps-test>
Pour supprimer les points d’arrêt, utilisez les applets de commande Get-PsBreakpoint et Remove-PsBreakpoint.
PS C:\ps-test> Get-PsBreakpoint | Remove-PSBreakpoint
Créez un point d’arrêt de commande sur la fonction PsVersion.
PS C:\ps-test> Set-PsBreakpoint -command psversion -script test.ps1
Vous pouvez abréger cette commande comme suit :
PS C:\ps-test> sbp -c psversion -s test.ps1
Maintenant, exécutez le script.
PS C:\ps-test> .\test.ps1
Hit Command breakpoint on 'C:\ps-test\test.ps1:psversion'
test.ps1:12 psversion
DBG>
Le script atteint le point d’arrêt sur l’appel de fonction. À ce stade, la fonction n’a pas encore été appelée. Cela vous donne la possibilité d’utiliser le paramètre Action de Set-PsBreakpoint pour définir des conditions d’exécution du point d’arrêt ou effectuer des tâches de préparation ou de diagnostic, telles que le démarrage d’un journal ou l’appel d’un script de diagnostic ou de sécurité.
Pour définir une action, utilisez une commande Continue (c) pour quitter le script et une commande Remove-PsBreakpoint pour supprimer le point d’arrêt actuel. (Les points d’arrêt étant en lecture seule, vous ne pouvez pas ajouter une action au point d’arrêt actuel.)
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>
À présent, créez un point d’arrêt de commande avec une action. La commande suivante définit un point d’arrêt de commande avec une action qui enregistre la valeur de la variable $scriptname quand la fonction est appelée. Le mot clé Break n’étant pas utilisé dans l’action, l’exécution ne s’arrête pas. (L’accent grave (`) est le caractère de continuation de ligne.)
PS C:\ps-test> set-psbreakpoint -command psversion -script test.ps1 `
-action { add-content "The value of `$scriptname is $scriptname." `
-path action.log}
Vous pouvez également ajouter des actions qui définissent des conditions pour le point d’arrêt. Dans la commande suivante, le point d’arrêt de commande est exécuté uniquement si la stratégie d’exécution a pour valeur RemoteSigned, la stratégie la plus restrictive qui vous autorise cependant à exécuter des scripts. (L’accent grave (`) est le caractère de continuation.)
PS C:\ps-test> set-psbreakpoint -script test.ps1 -command psversion `
-action { if ((get-executionpolicy) -eq "RemoteSigned") { break }}
Le mot clé Break dans l’action indique au débogueur d’exécuter le point d’arrêt. Vous pouvez également utiliser le mot clé Continue pour demander au débogueur une exécution sans interruption. Étant donné que le mot clé par défaut est Continue, vous devez spécifier Break pour arrêter l’exécution.
Maintenant, exécutez le script.
PS C:\ps-test> .\test.ps1
Hit Command breakpoint on 'C:\ps-test\test.ps1:psversion'
test.ps1:12 psversion
Étant donné que la stratégie d’exécution a la valeur RemoteSigned, l’exécution s’arrête sur l’appel de fonction.
À ce stade, vous voulez peut-être vérifier la pile des appels. Utilisez l’applet de commande Get-PsCallStack ou la commande de débogueur Get-PsCallStack (k). La commande suivante obtient la pile des appels actuelle.
DBG> k
2: prompt
1: .\test.ps1: $args=[]
0: prompt: $args=[]
Cet exemple ne montre que quelques-unes des nombreuses façons d’utiliser le débogueur Windows PowerShell.
Pour plus d’informations sur les applets de commande du débogueur, tapez la commande suivante :
help <cmdlet-name> -full
Par exemple, tapez :
help set-psbreakpoint -full
AUTRES FONCTIONNALITÉS DE DÉBOGAGE DANS WINDOWS POWERSHELL
En plus du débogueur Windows PowerShell, Windows PowerShell inclut plusieurs autres fonctionnalités que vous pouvez utiliser pour déboguer des scripts et des fonctions.
-- Windows PowerShell Integrated Scripting Environment (ISE) includes
an interactive graphical debugger. For more information, start Windows
PowerShell ISE and press F1.
-- The Set-PSDebug cmdlet offers very basic script debugging features,
including stepping and tracing.
-- 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.
-- 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. Use the cmdlets that contain the Write verb for
this task, such as Write-Host, Write-Debug, Write-Warning, and
Write-Verbose.
VOIR AUSSI
Disable-PsBreakpoint
Enable-PsBreakpoint
Get-PsBreakpoint
Get-PsCallStack
Remove-PsBreakpoint
Set-PsBreakpoint
Set-PsDebug
Set-Strictmode
Write-Debug
Write-Verbose