about_Debuggers
Se aplica a: Windows PowerShell 2.0, Windows PowerShell 3.0
Insertar la introducción aquí.
TEMA
about_Debuggers
DESCRIPCIÓN BREVE
Describe el depurador de Windows PowerShell®.
DESCRIPCIÓN LARGA
La depuración es el proceso de análisis de un script mientras se está ejecutando para identificar y corregir errores en las instrucciones del script. El depurador de Windows PowerShell está diseñado para ayudarle a examinar e identificar errores e ineficacias en scripts, funciones, comandos, flujos de trabajo de Windows PowerShell o expresiones.
En Windows PowerShell 4.0, el depurador de Windows PowerShell se actualizó para depurar scripts, funciones, flujos de trabajo, comandos o expresiones que se ejecutan en la consola de Windows PowerShell (no ISE) en equipos remotos. Puede ejecutar Enter-PSSession para iniciar una sesión de PowerShell remota e interactiva en la que puede establecer puntos de interrupción y depurar comandos y archivos de script en el equipo remoto. La funcionalidad Enter-PSSession se actualizó para que pueda volver a conectarse y escribir una sesión desconectada en la que se ejecuta un script o un comando en un equipo remoto. Si el script en ejecución llega a un punto de interrupción, la sesión de cliente inicia automáticamente el depurador. Si la sesión desconectada que ejecuta un script ya alcanzó un punto de interrupción y se detiene en el punto de interrupción, Enter-PSSession inicia automáticamente el depurador de línea de comandos, cuando vuelva a conectarse a la sesión.
El depurador Windows PowerShell 4.0 también puede utilizarse para depurar flujos de trabajo de Windows PowerShell, bien en la consola de Windows PowerShell o en el ISE de Windows PowerShell.
Puede usar las características del depurador de Windows PowerShell para examinar una expresión, un flujo de trabajo, un comando, una función o un script de Windows PowerShell mientras se está ejecutando. El depurador de Windows PowerShell incluye un conjunto de cmdlets que le permiten establecer puntos de interrupción, administrarlos y ver la pila de llamadas.
CMDLETS DEL DEPURADOR
El depurador de Windows PowerShell incluye el siguiente conjunto de cmdlets:
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.
INICIO Y DETENCIÓN DEL DEPURADOR
Para iniciar el depurador, establezca uno o varios puntos de interrupción. Después, ejecute el script, el comando o la función que quiere depurar.
Cuando llegue a un punto de interrupción, se detiene la ejecución y el control se pasa al depurador.
Para detener al depurador, ejecute el script, el comando o la función hasta que se complete. O bien, escriba "stop" o "t".
COMANDOS DEL DEPURADOR
Cuando se utiliza el depurador la consola de Windows PowerShell, utilice los comandos siguientes para controlar la ejecución. En el ISE Windows PowerShell, use los comandos del menú Depurar.
Nota: para obtener información sobre cómo utilizar el depurador en otras aplicaciones host, consulte la documentación de la aplicación host.
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).
Mediante estos comandos de depurador, puede ejecutar un script, detenerlo en un punto de interés, examinar los valores de las variables y el estado del sistema y continuar ejecutando el script hasta que identifique un problema.
NOTA:
si recorre paso a paso por instrucciones en una instrucción con un operador de redirección, como ">", el depurador de Windows PowerShell recorre paso a paso por procedimientos todas las instrucciones restantes del script.
VISUALIZACIÓN DE LOS VALORES DE LAS VARIABLES DE SCRIPT
Mientras está en el depurador, también puede escribir comandos, mostrar el valor de las variables, usar cmdlets y ejecutar scripts en la línea de comandos.
Puede mostrar el valor actual de todas las variables del script que se está depurando, excepto las siguientes variables automáticas:
$_
$Args
$Input
$MyInvocation
$PSBoundParameters
Si intenta mostrar el valor de cualquiera de estas variables, obtendrá el valor de esa variable en una canalización interna que utiliza el depurador, no el valor de la variable en el script.
Para mostrar el valor de estas variables para el script que se está depurando, en el script, asigne el valor de la variable automática a una nueva variable. Entonces podrá mostrar el valor de la nueva variable.
Por ejemplo,
$scriptArgs = $Args
$scriptArgs
En el ejemplo de este tema, el valor de la variable $MyInvocation se reasigna como sigue:
$scriptname = $MyInvocation.MyCommand.Path
EL ENTORNO DEL DEPURADOR
Cuando llegue a un punto de interrupción, escriba el entorno del depurador. El símbolo del sistema cambia para que comience con "[DBG]:". Si está depurando un flujo de trabajo, el símbolo del sistema es "[WFDBG]". Puede personalizar el símbolo del sistema.
Además, en algunas aplicaciones host, como la consola de Windows PowerShell, (pero no en el Entorno de scripting integrado [ISE] de Windows PowerShell), se abre un símbolo del sistema anidado para la depuración. Puede identificar el símbolo del sistema anidado por los caracteres de mayor que (62 en ASCII) que aparecen en el símbolo del sistema.
Por ejemplo, a continuación se muestra el símbolo del sistema de depuración predeterminado en la consola de Windows PowerShell:
[DBG]: PS (get-location)>>>
Puede conocer el nivel de anidamiento mediante el uso de la variable automática $NestedPromptLevel.
Además, se define una variable automática, $PSDebugContext, en el ámbito local. Puede aprovechar la existencia de la variable $PsDebugContext para determinar si se encuentra en el depurador.
Por ejemplo:
if ($psdebugcontext) {"Debugging"} else {"Not Debugging"}
Puede usar el valor de la variable $PSDebugContext en la depuración.
[DBG]: PS>>> $psdebugcontext.invocationinfo
Name CommandLineParameters UnboundArguments Location
---- --------------------- ---------------- --------
= {} {} C:\ps-test\vote.ps1 (1)
DEPURACIÓN Y ÁMBITO
La interrupción en el depurador no cambia el ámbito en el que está trabajando, pero cuando llega a un punto de interrupción de un script, se desplaza al ámbito del script. El ámbito del script es un elemento secundario del ámbito en el que se ejecutó el depurador.
Para buscar las variables y los alias definidos en el ámbito del script, utilice el parámetro Scope de los cmdlets Get-Alias o Get-Variable.
Por ejemplo, el siguiente comando obtiene las variables en el ámbito (de script) local:
get-variable -scope 0
El comando se puede abreviar como:
gv -s 0
Se trata de una manera útil de ver solo las variables que definió en el script y durante la depuración.
DEPURACIÓN EN LA LÍNEA DE COMANDOS
Cuando establece un punto de interrupción de variable o un punto de interrupción de comando, puede establecer el punto de interrupción solo en un archivo de script. Sin embargo, de forma predeterminada, el punto de interrupción se establece en cualquier equipo que se ejecute en la sesión actual.
Por ejemplo, si establece un punto de interrupción en la variable $name, el depurador se interrumpe en cualquier variable $name de cualquier script, comando, función, cmdlet de script o expresión que ejecute hasta que deshabilite o quite el punto de interrupción.
Esto permite depurar los scripts en un contexto más realista en el que podrían verse afectados por funciones, variables y otros scripts de la sesión y del perfil del usuario.
Los puntos de interrupción de línea son específicos para los archivos de script, por lo que solo se establecen en ellos.
DEPURACIÓN DE FLUJOS DE TRABAJO
El depurador Windows PowerShell 4.0 puede utilizarse para depurar flujos de trabajo de Windows PowerShell, bien en la consola de Windows PowerShell o en el ISE de Windows PowerShell. Existen algunas limitaciones respecto al uso de depurador de Windows PowerShell para depurar flujos de trabajo.
-- 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.
En el ejemplo siguiente se muestra cómo depurar un flujo de trabajo. Tenga en cuenta que cuando el depurador pasa a la función de flujo de trabajo, el símbolo del sistema del depurador cambia a [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.
FUNCIONES DE DEPURACIÓN
Al establecer un punto de interrupción en una función que tenga secciones Begin, Process y End, el depurador se interrumpe en la primera línea de cada sección.
Por ejemplo:
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>
DEPURACIÓN SCRIPTS REMOTOS
En Windows PowerShell 4.0, puede ejecutar el depurador de Windows PowerShell en una sesión remota, en al consola de Windows PowerShell 4.0. La funcionalidad Enter-PSSession se actualizó para que pueda volver a conectarse y escribir una sesión desconectada que se ejecuta en un equipo remoto y está ejecutando actualmente un script. Si el script en ejecución llega a un punto de interrupción, la sesión de cliente inicia automáticamente el depurador. A continuación se muestra un ejemplo donde se aprecia cómo funciona, con puntos de interrupción establecidos en las líneas 6, 11, 22 y 25 de un script. Tenga en cuenta que en el ejemplo, cuando se inicia el depurador, hay dos símbolos de sistema de identificación: el nombre del equipo en el que se ejecuta la sesión y el símbolo del sistema DBG que le permite saber que está en modo de depuración.
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>
EJEMPLOS
Este script de prueba detecta la versión del sistema operativo y muestra un mensaje de sistema adecuado. Incluye una función, una llamada de función y una variable.
El comando siguiente muestra el contenido del archivo del script de prueba:
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."
Para comenzar, establezca un punto de interrupción en un punto de interés del script, como una línea, un comando, una variable o una función.
Comience por la creación de un punto de interrupción de línea en la primera línea del script Test.ps1 del directorio actual.
PS C:\ps-test> set-psbreakpoint -line 1 -script test.ps1
Este comando se puede abreviar como:
PS C:\ps-test> spb 1 -s test.ps1
El comando devuelve un objeto de punto de interrupción de línea (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
Ahora, inicie el script.
PS C:\ps-test> .\test.ps1
Cuando el script llega el primer punto de interrupción, el mensaje del punto de interrupción indica que el depurador está activo. Describe el punto de interrupción y muestra una vista previa de la primera línea del script, que es una declaración de función. El símbolo del sistema también cambia para indicar que el depurador tiene el control.
La línea de vista previa incluye el nombre del script y el número de línea del comando del cual se muestra la vista previa.
Entering debug mode. Use h or ? for help.
Hit Line breakpoint on 'C:\ps-test\test.ps1:1'
test.ps1:1 function psversion {
DBG>
Utilice el comando Ejecutar paso a paso (s) para ejecutar la primera instrucción del script y obtener una vista previa de la siguiente instrucción. La instrucción siguiente utiliza la variable automática $MyInvocation para establecer el valor de la variable $ScriptName en la ruta de acceso y el nombre del archivo de script.
DBG> s
test.ps1:11 $scriptname = $MyInvocation.MyCommand.Path
En este momento no se rellena la variable $ScriptName, pero puede comprobar el valor de la variable si muestra su valor. En este caso, el valor es $null.
DBG> $scriptname
DBG>
Utilice otro comando comando Ejecutar paso a paso (s) para ejecutar la instrucción actual y obtener una vista previa de la siguiente instrucción del script. La siguiente instrucción llama a la función PsVersion.
DBG> s
test.ps1:12 psversion
En este momento se rellena la variable $ScriptName y para comprobar el valor de la variable puede mostrar su valor. En este caso, el valor se establece como la ruta de acceso del script.
DBG> $scriptname
C:\ps-test\test.ps1
Utilice otro comando Ejecutar paso a paso para ejecutar la llamada de función. Presione ENTRAR o escriba "s" para Ejecutar paso a paso.
DBG> s
test.ps1:2 "Windows PowerShell " + $psversiontable.psversion
El mensaje de depuración incluye una vista previa de la instrucción de la función. Para ejecutar esta instrucción y obtener una vista previa de la siguiente instrucción de la función, puede usar un comando Paso. Sin embargo, en este caso, use un comando Paso a paso para salir (o). Se completa la ejecución de la función (a menos que se alcance un punto de interrupción) y continúa hasta la siguiente instrucción del script.
DBG> o
Windows PowerShell 2.0
Have you run a background job today (start-job)?
test.ps1:13 "Done $scriptname"
Dado que estamos en la última instrucción del script, los comandos Ejecutar paso a paso, Paso a paso para salir y Continuar tienen el mismo efecto. En este caso, utilice Paso a paso para salir (o).
Done C:\ps-test\test.ps1
PS C:\ps-test>
El comando Paso a paso para salir ejecuta el último comando. El símbolo del sistema estándar indica que el depurador terminó y devuelve el control al procesador de comandos.
Ahora, ejecute de nuevo el depurador. En primer lugar, para eliminar el punto de interrupción actual, use los cmdlets Get-PsBreakpoint y Remove-PsBreakpoint. (Si cree que podría volver a utilizar el punto de interrupción, use el cmdlet Disable-PsBreakpoint en lugar de Remove-PsBreakpoint).
PS C:\ps-test> Get-PsBreakpoint | Remove-PSBreakpoint
Este comando se puede abreviar como:
PS C:\ps-test> gbp | rbp
O bien ejecute el comando escribiendo una función, como la siguiente:
function delbr { gbp | rbp }
Ahora, cree un punto de interrupción en la variable $scriptname.
PS C:\ps-test> set-psbreakpoint -variable scriptname -script test.ps1
El comando se puede abreviar como:
PS C:\ps-test> sbp -v scriptname -s test.ps1
Ahora, inicie el script. El script alcanza el punto de interrupción de variable. El modo predeterminado es Write, por lo que la ejecución se detiene justo antes de la instrucción que cambia el valor 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>
Muestre el valor actual de la variable $scriptname, que es $null.
DBG> $scriptname
DBG>
Utilice un comando Ejecutar paso a paso (s) para ejecutar la instrucción que rellena la variable. Después, muestre el nuevo valor de la variable $scriptname.
DBG> $scriptname
C:\ps-test\test.ps1
Utilice un comando Ejecutar paso a paso (s) para obtener una vista previa de la siguiente instrucción del script.
DBG> s
test.ps1:12 psversion
La siguiente instrucción es una llamada a la función PsVersion. Para omitir la función pero aun así ejecutarla, use un comando Paso a paso por procedimientos (v). Si ya está en la función cuando utiliza Paso a paso por procedimientos, no es eficaz. Se muestra la llamada de función, pero no se ejecuta.
DBG> v
Windows PowerShell 2.0
Have you run a background job today (start-job)?
test.ps1:13 "Done $scriptname"
El comando Paso a paso por procedimientos ejecuta la función y muestra una vista previa de la siguiente instrucción en el script, que imprime la última línea.
Utilice un comando Detener (t) para salir del depurador. El símbolo del sistema vuelve a la línea de comandos estándar.
C:\ps-test>
Para eliminar los puntos de interrupción, use los cmdlets Get-PsBreakpoint y Remove-PsBreakpoint.
PS C:\ps-test> Get-PsBreakpoint | Remove-PSBreakpoint
Cree un nuevo punto de interrupción de comando en la función PsVersion.
PS C:\ps-test> Set-PsBreakpoint -command psversion -script test.ps1
Puede abreviar este comando a:
PS C:\ps-test> sbp -c psversion -s test.ps1
Ahora, ejecute el script.
PS C:\ps-test> .\test.ps1
Hit Command breakpoint on 'C:\ps-test\test.ps1:psversion'
test.ps1:12 psversion
DBG>
El script alcanza el punto de interrupción en la llamada de función. En este momento, aún no se ha llamado a la función. Esto le ofrece la posibilidad de usar el parámetro Action de Set-PsBreakpoint a fin de establecer condiciones para la ejecución del punto de interrupción o para realizar tareas preparatorias o de diagnóstico, como iniciar un registro o invocar script de seguridad o diagnóstico.
Para establecer una acción, use un comando Continuar (c) para salir del script y un comando Remove-PsBreakpoint para eliminar el punto de interrupción actual. (Los puntos de interrupción son de solo lectura, por lo que no se puede agregar una acción al punto de interrupción actual).
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>
Ahora, cree un nuevo punto de interrupción de comando con una acción. El comando siguiente establece un punto de interrupción de comando con una acción que registra el valor de la variable $scriptname cuando se llama a la función. Dado que no se utiliza la palabra clave Break en la acción, la ejecución no se detiene. (El acento grave (`) es el carácter de continuación de línea).
PS C:\ps-test> set-psbreakpoint -command psversion -script test.ps1 `
-action { add-content "The value of `$scriptname is $scriptname." `
-path action.log}
También puede agregar acciones que establezcan condiciones para el punto de interrupción. En el siguiente comando, el punto de interrupción de comando se ejecuta solo si la directiva de ejecución se establece como RemoteSigned, la directiva más restrictiva que permite ejecutar scripts. (El acento grave (`) es el carácter de continuación).
PS C:\ps-test> set-psbreakpoint -script test.ps1 -command psversion `
-action { if ((get-executionpolicy) -eq "RemoteSigned") { break }}
La palabra clave Break en la acción indica al depurador que ejecute el punto de interrupción. También puede usar la palabra clave Continue para indicar al depurador que ejecute sin interrupciones. Dado que la palabra clave predeterminada es Continue, debe especificar Break para detener la ejecución.
Ahora, ejecute el script.
PS C:\ps-test> .\test.ps1
Hit Command breakpoint on 'C:\ps-test\test.ps1:psversion'
test.ps1:12 psversion
Como la directiva de ejecución está establecida como RemoteSigned, la ejecución se detiene en la llamada de función.
En este punto, es recomendable comprobar la pila de llamadas. Use el cmdlet Get-PsCallStack o el comando del depurador Get-PsCallStack (k). El comando siguiente obtiene la pila de llamadas actual.
DBG> k
2: prompt
1: .\test.ps1: $args=[]
0: prompt: $args=[]
En este ejemplo se muestran solo algunas de las muchas maneras de usar el depurador de Windows PowerShell.
Para más información sobre los cmdlets del depurador, escriba el comando siguiente:
help <cmdlet-name> -full
Por ejemplo, escriba:
help set-psbreakpoint -full
OTRAS CARACTERÍSTICAS DE DEPURACIÓN EN WINDOWS POWERSHELL
Además del depurador de Windows PowerShell, Windows PowerShell incluye otras funciones que puede utilizar para depurar scripts y funciones.
-- 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.
VEA TAMBIÉN
Disable-PsBreakpoint
Enable-PsBreakpoint
Get-PsBreakpoint
Get-PsCallStack
Remove-PsBreakpoint
Set-PsBreakpoint
Set-PsDebug
Set-Strictmode
Write-Debug
Write-Verbose