about_Debuggers
Aplica-se a: Windows PowerShell 2.0, Windows PowerShell 3.0, Windows PowerShell 4.0, Windows PowerShell 5.0
Insira a introdução aqui.
TÓPICO
about_Debuggers
DESCRIÇÃO BREVE
Descreve o depurador do Windows PowerShell®.
DESCRIÇÃO LONGA
A depuração é o processo de examinar um script enquanto ele é executado para identificar e corrigir erros nas instruções do script. O depurador do Windows PowerShell foi projetado para ajudar você a examinar e identificar erros e ineficiências em seus scripts, funções, comandos, fluxos de trabalho do Windows PowerShell ou expressões.
No Windows PowerShell 4.0, o depurador do Windows PowerShell foi atualizado para depurar scripts, funções, fluxos de trabalho, comandos ou expressões que estejam em execução no console do Windows PowerShell (não ISE) em computadores remotos. Você pode executar Enter-PSSession para iniciar uma sessão interativa remota do PowerShell na qual pode configurar pontos de interrupção e depurar arquivos e comandos de scripts no computador remoto. A funcionalidade ENTER-PSSession foi atualizada para permitir que você se reconecte e entre em uma sessão desconectada que esteja executando um comando ou script em um computador remoto. Se o script em execução atingir um ponto de interrupção, sua sessão do cliente iniciará o depurador automaticamente. Se a sessão desconectada que estiver executando um script já tiver atingido um ponto de interrupção e for interrompida no ponto de interrupção, a Enter-PSSession iniciará automaticamente o depurador de linha de comando depois que você se reconectar à sessão.
O depurador do Windows PowerShell 4.0 também pode ser usado para depurar os fluxos de trabalho do Windows PowerShell, seja no console do Windows PowerShell ou no ISE do Windows PowerShell.
Você pode usar os recursos do depurador do Windows PowerShell para examinar um script, função, comando, fluxo de trabalho ou expressão do Windows PowerShell enquanto ele estiver em execução. O depurador do Windows PowerShell inclui um conjunto de cmdlets que permite que você configure pontos de interrupção, gerencie pontos de interrupção e exiba a pilha de chamadas.
CMDLETS DO DEPURADOR
O depurador do Windows PowerShell inclui o seguinte 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.
INÍCIO E INTERRUPÇÃO DO DEPURADOR
Para iniciar o depurador, configure um ou mais pontos de interrupção. Em seguida, execute o script, comando ou função que deseja depurar.
Quando você atingir um ponto de interrupção, a execução será interrompida e o controle será transferido ao depurador.
Para interromper o depurador, execute o script, comando ou função até sua conclusão. Ou digite "stop" ou "t".
COMANDOS DO DEPURADOR
Quando você usa o depurador no console do Windows PowerShell, use os seguintes comandos para controlar a execução. No ISE do Windows PowerShell, use os comandos no menu Depurar.
Observação: Para obter informações sobre como usar o depurador em outros aplicativos host, consulte a documentação sobre aplicativos 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).
Usando esses comandos do depurador, você pode executar um script, interromper a execução em um ponto de interesse, examinar os valores das variáveis e o estado do sistema, e continuar executando o script até identificar um problema.
OBSERVAÇÃO:
Se você entrar em uma instrução com um operador de redirecionamento, como ">", o depurador do Windows PowerShell ignorará todas as instruções restantes no script.
EXIBIÇÃO DOS VALORES DAS VARIÁVEIS DOS SCRIPTS
Enquanto você estiver no depurador, também pode inserir comandos, exibir o valor das variáveis, usar os cmdlets e executar scripts na linha de comando.
Você pode exibir o valor atual de todas as variáveis do script que está sendo depurado, exceto as seguintes variáveis automáticas:
$_
$Args
$Input
$MyInvocation
$PSBoundParameters
Se você tentar exibir o valor de qualquer uma dessas variáveis, obterá o valor dessa variável em um pipeline interno usado pelo depurador, e não o valor da variável no script.
Para exibir o valor dessas variáveis para o script que está sendo depurado, no script, atribua o valor da variável automática a uma nova variável. Em seguida, você pode exibir o valor da nova variável.
Por exemplo,
$scriptArgs = $Args
$scriptArgs
No exemplo deste tópico, o valor da variável $MyInvocation é reatribuído da seguinte maneira:
$scriptname = $MyInvocation.MyCommand.Path
O AMBIENTE DO DEPURADOR
Quando você atingir um ponto de interrupção, poderá entrar no ambiente do depurador. O prompt de comando muda para começar com "[DBG]:". Se você estiver depurando um fluxo de trabalho, o prompt é "[WFDBG]". Você pode personalizar o prompt.
Além disso, em alguns aplicativos host, como o console do Windows PowerShell (mas não no ISE (Ambiente de Scripting Integrado) do Windows PowerShell), um prompt aninhado é aberto para depuração. Você pode detectar o prompt aninhado repetindo os caracteres 'maior que' (ASCII 62) que aparecem no prompt de comando.
Por exemplo, o seguinte é o prompt padrão de depuração no console do Windows PowerShell:
[DBG]: PS (get-location)>>>
Você pode encontrar o nível de aninhamento usando a variável automática $NestedPromptLevel.
Além disso, uma variável automática, $PSDebugContext, é definida no escopo local. Você pode usar a presença da variável $PsDebugContext para determinar se você está no depurador.
Por exemplo:
if ($psdebugcontext) {"Debugging"} else {"Not Debugging"}
Você pode usar o valor da variável $PSDebugContext em sua depuração.
[DBG]: PS>>> $psdebugcontext.invocationinfo
Name CommandLineParameters UnboundArguments Location
---- --------------------- ---------------- --------
= {} {} C:\ps-test\vote.ps1 (1)
DEPURAÇÃO E ESCOPO
Interromper o depurador não altera o escopo no qual você está operando, mas, quando você atingir um ponto de interrupção em um script, você será movido para o escopo do script. O escopo do script é um filho do escopo no qual você executou o depurador.
Para localizar as variáveis e os aliases que são definidos no escopo do script, use o parâmetro Scope dos cmdlets Get-Alias ou Get-Variable.
Por exemplo, o comando a seguir obtém as variáveis do escopo local (script):
get-variable -scope 0
Você pode abreviar o comando como:
gv -s 0
Essa é uma maneira útil de ver somente as variáveis definidas no script e que foram definidas durante a depuração.
DEPURAÇÃO NA LINHA DE COMANDO
Quando você configura um ponto de interrupção de variável ou um ponto de interrupção de comando, você só pode configurar o ponto de interrupção em um arquivo de script. No entanto, por padrão, o ponto de interrupção é configurado em qualquer coisa que seja executada na sessão atual.
Por exemplo, se você configurar um ponto de interrupção na variável $name, o depurador será interrompido em qualquer variável $name de qualquer script, comando, função, cmdlet de script ou expressão que você executar até que o ponto de interrupção seja desabilitado ou removido.
Isso permite que você depure seus scripts em um contexto mais realista no qual eles podem ser afetados pela funções, variáveis e outros scripts da sessão e do perfil do usuário.
Os pontos de interrupção de linha são específicos dos arquivos de script, para que eles sejam definidos apenas em arquivos de script.
DEPURAÇÃO DE FLUXOS DE TRABALHO
O depurador do Windows PowerShell 4.0 também pode ser usado para depurar os fluxos de trabalho do Windows PowerShell, seja no console do Windows PowerShell ou no ISE do Windows PowerShell. Existem algumas limitações ao uso do depurador do Windows PowerShell para a depuração de fluxos de trabalho.
-- 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.
O exemplo a seguir demonstra a depuração de um fluxo de trabalho. Observe que, quando o depurador avança para a função de fluxo de trabalho, o prompt do depurador muda para [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.
FUNÇÕES DE DEPURAÇÃO
Quando você configura um ponto de interrupção em uma função que tem seções Begin, Process e End, o depurador fará a interrupção na primeira linha de cada seção.
Por exemplo:
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>
DEPURAÇÃO DE SCRIPTS REMOTOS
No Windows PowerShell 4.0, você pode executar o depurador do Windows PowerShell em uma sessão remota, no console do Windows PowerShell 4.0. A funcionalidade ENTER-PSSession foi atualizada para permitir que você se reconecte e entre em uma sessão desconectada que esteja em execução em um computador remoto e, no momento, executando um script. Se o script em execução atingir um ponto de interrupção, sua sessão do cliente iniciará o depurador automaticamente. A seguir, há um exemplo que mostra como isso funciona, com pontos de interrupção configurados em um script nas linhas 6, 11, 22 e 25. Observe que, no exemplo, quando o depurador é iniciado, há dois prompts de identificação: o nome do computador no qual a sessão está em execução, e o prompt DBG que permite saber que você está no modo de depuração.
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>
EXEMPLOS
Esse script de teste detecta a versão do sistema operacional e exibe uma mensagem adequada ao sistema. Ele inclui uma função, uma chamada de função e uma variável.
O comando a seguir exibe o conteúdo do arquivo de script de teste:
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 começar, configure um ponto de interrupção em um ponto de interesse do script, como uma linha, comando, variável ou função.
Comece criando um ponto de interrupção na primeira linha do script Test.ps1 na pasta atual.
PS C:\ps-test> set-psbreakpoint -line 1 -script test.ps1
Você pode abreviar esse comando como:
PS C:\ps-test> spb 1 -s test.ps1
O comando retorna um objeto de ponto de interrupção (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
Agora, inicie o script.
PS C:\ps-test> .\test.ps1
Quando o script atingir o primeiro ponto de interrupção, a mensagem do ponto de interrupção indica que o depurador está ativo. Ele descreve o ponto de interrupção e visualiza a primeira linha do script, que é uma declaração de função. O prompt de comando também muda para indicar que o depurador tem controle.
A linha de visualização inclui o nome do script e o número de linha do comando visualizado.
Entering debug mode. Use h or ? for help.
Hit Line breakpoint on 'C:\ps-test\test.ps1:1'
test.ps1:1 function psversion {
DBG>
Use o comando Step (s) para executar a primeira instrução no script e visualizar a próxima instrução. A próxima instrução usa a variável automática $MyInvocation para configurar o valor da variável $ScriptName o caminho e o nome do arquivo de script.
DBG> s
test.ps1:11 $scriptname = $MyInvocation.MyCommand.Path
Neste ponto, a variável $ScriptName não está preenchida, mas você pode verificar o valor da variável exibindo seu valor. Nesse caso, o valor é $null.
DBG> $scriptname
DBG>
Use outro comando Step (s) para executar a instrução atual e visualizar a próxima instrução no script. A próxima instrução chama a função PsVersion.
DBG> s
test.ps1:12 psversion
Neste ponto, a variável $ScriptName está preenchida, mas você pode verificar o valor da variável exibindo seu valor. Nesse caso, o valor é configurado como o caminho do script.
DBG> $scriptname
C:\ps-test\test.ps1
Use outro comando Step para executar a chamada de função. Pressione ENTER ou digite "s" para Step.
DBG> s
test.ps1:2 "Windows PowerShell " + $psversiontable.psversion
A mensagem de depuração inclui uma visualização da instrução na função. Para executar essa instrução e visualizar a próxima instrução na função, você pode usar um comando Step. Mas, nesse caso, use um comando Step-Out (o). Ele conclui a execução da função (a menos que atinja um ponto de interrupção) e as etapas para a próxima instrução do script.
DBG> o
Windows PowerShell 2.0
Have you run a background job today (start-job)?
test.ps1:13 "Done $scriptname"
Como estamos na última instrução no script, os comandos Step, Step-Out e Continue têm o mesmo efeito. Nesse caso, use Step-Out (o).
Done C:\ps-test\test.ps1
PS C:\ps-test>
O comando Step-Out executa o último comando. O prompt de comando padrão indica que o depurador foi encerrado e retorna o controle para o processador de comando.
Agora, execute o depurador novamente. Primeiro, para excluir o ponto de interrupção atual, use os cmdlets Get-PsBreakpoint e Remove-PsBreakpoint. (Se você acha que você pode reutilizar o ponto de interrupção, use o cmdlet Disable-PsBreakpoint em vez de Remove-PsBreakpoint.)
PS C:\ps-test> Get-PsBreakpoint | Remove-PSBreakpoint
Você pode abreviar esse comando como:
PS C:\ps-test> gbp | rbp
Ou execute o comando gravando uma função como a seguir:
function delbr { gbp | rbp }
Agora, crie um ponto de interrupção na variável $scriptname.
PS C:\ps-test> set-psbreakpoint -variable scriptname -script test.ps1
Você pode abreviar o comando como:
PS C:\ps-test> sbp -v scriptname -s test.ps1
Agora, inicie o script. O script atinge o ponto de interrupção da variável. O modo padrão é Write; portanto, a execução é interrompida logo antes da instrução que altera o valor da variável.
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>
Exiba o valor atual da variável $scriptname, que é $null.
DBG> $scriptname
DBG>
Use um Step (s) para executar a instrução que preenche a variável. Em seguida, exiba o novo valor da variável $scriptname.
DBG> $scriptname
C:\ps-test\test.ps1
Use um comando Step (s) para visualizar a próxima instrução do script.
DBG> s
test.ps1:12 psversion
A próxima instrução é uma chamada para a função PsVersion. Para ignorar a função, mas ainda executá-la, use um comando Step-Over (v). Se você já estiver na função ao usar o Step-Over, o comando não será eficaz. A chamada de função é exibida, mas não será executada.
DBG> v
Windows PowerShell 2.0
Have you run a background job today (start-job)?
test.ps1:13 "Done $scriptname"
O comando Step-Over executa a função e visualiza a próxima instrução no script, que imprime a linha final.
Use um comando Stop (t) para sair do depurador. O prompt de comando será revertido para o prompt padrão de comando.
C:\ps-test>
Para excluir os pontos de interrupção, use os cmdlets Get-PsBreakpoint e Remove-PsBreakpoint.
PS C:\ps-test> Get-PsBreakpoint | Remove-PSBreakpoint
Crie um novo ponto de interrupção do comando na função PsVersion.
PS C:\ps-test> Set-PsBreakpoint -command psversion -script test.ps1
Você pode abreviar esse comando como:
PS C:\ps-test> sbp -c psversion -s test.ps1
Agora, execute o script.
PS C:\ps-test> .\test.ps1
Hit Command breakpoint on 'C:\ps-test\test.ps1:psversion'
test.ps1:12 psversion
DBG>
O script atinge o ponto de interrupção na chamada de função. Nesse ponto, a função ainda não foi chamada. Isso oferece a oportunidade de usar o parâmetro Action do Set-PsBreakpoint para configurar as condições para a execução do ponto de interrupção ou para executar tarefas de diagnóstico ou preparatórias, como iniciar um log ou acionar um script de diagnóstico ou segurança.
Para configurar uma ação, use um comando Continue (c) para sair do script e um comando Remove-PsBreakpoint para excluir o ponto de interrupção atual. (Os pontos de interrupção são somente leitura; portanto, você não pode adicionar uma ação ao ponto de interrupção atual.)
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>
Agora, crie um novo ponto de interrupção de comando com uma ação. O comando a seguir configura um ponto de interrupção de comando com uma ação que registra o valor da variável $scriptname quando a função for chamada. Já que a palavra-chave Break não é usada na ação, a execução não é interrompida. (O backtick (`) é o caractere de continuação de linha.)
PS C:\ps-test> set-psbreakpoint -command psversion -script test.ps1 `
-action { add-content "The value of `$scriptname is $scriptname." `
-path action.log}
Você também pode adicionar ações que configuram condições para o ponto de interrupção. No comando a seguir, o ponto de interrupção do comando é executado apenas se a política de execução for configurada como RemoteSigned, a política mais restritiva que ainda permite a execução de scripts. (O backtick (`) é o caractere de continuação.)
PS C:\ps-test> set-psbreakpoint -script test.ps1 -command psversion `
-action { if ((get-executionpolicy) -eq "RemoteSigned") { break }}
A palavra-chave Break da ação instrui o depurador a executar o ponto de interrupção. Você também pode usar a palavra-chave Continue para direcionar o depurador a executar sem interrupções. Já que a palavra-chave default é Continue, você deve especificar Break para interromper a execução.
Agora, execute o script.
PS C:\ps-test> .\test.ps1
Hit Command breakpoint on 'C:\ps-test\test.ps1:psversion'
test.ps1:12 psversion
Já que a política de execução está configurada como RemoteSigned, a execução será interrompida na chamada de função.
Nesse ponto, convém verificar a pilha de chamadas. Use o cmdlet Get-PsCallStack ou o comando Get-PsCallStack (k) do depurador. O comando a seguir obtém a pilha de chamadas atual.
DBG> k
2: prompt
1: .\test.ps1: $args=[]
0: prompt: $args=[]
Este exemplo demonstra algumas das diversas formas de usar o depurador do Windows PowerShell.
Para obter mais informações sobre os cmdlets do depurador, digite o seguinte comando:
help <cmdlet-name> -full
Por exemplo, digite:
help set-psbreakpoint -full
OUTROS RECURSOS DE DEPURAÇÃO NO WINDOWS POWERSHELL
Além do depurador do Windows PowerShell, o Windows PowerShell inclui vários outros recursos que podem ser usados para depurar scripts e funções.
-- 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.
CONSULTE TAMBÉM
Disable-PsBreakpoint
Enable-PsBreakpoint
Get-PsBreakpoint
Get-PsCallStack
Remove-PsBreakpoint
Set-PsBreakpoint
Set-PsDebug
Set-Strictmode
Write-Debug
Write-Verbose