Sobre Debuggers

BREVE DESCRIÇÃO

Descreve o depurar powerShell.

LONGA DESCRIÇÃO

Depurar é o processo de examinar um script enquanto está em execução para identificar e corrigir erros nas instruções do script. O depurador PowerShell pode ajudá-lo a examinar e identificar erros e ineficiências nos seus scripts, funções, comandos, fluxos de trabalho PowerShell, configurações de configuração de estado (DSC) ou expressões.

A partir do PowerShell 5.0, o depurante PowerShell foi atualizado para depurar scripts, funções, fluxos de trabalho, comandos, configurações ou expressões que estão a ser executadas na consola ou no Windows PowerShell ISE em computadores remotos. Pode executar Enter-PSSession para iniciar uma sessão powerShell remota interativa na qual pode definir pontos de rutura e depurar ficheiros e comandos de scripts no computador remoto. Enter-PSSessiona funcionalidade foi atualizada para permitir que volte a ligar-se e introduzir uma sessão desligada que esteja a executar um script ou comando num computador remoto. Se o script de execução atingir um ponto de rutura, a sessão do seu cliente inicia automaticamente o depuração. Se a sessão desligada que está a executar um script já atingiu um ponto de rutura, e for interrompida no ponto de rutura, Enter-PSSession inicie automaticamente o depurar linha de comando, depois de voltar a ligar-se à sessão.

O depurar PowerShell também pode ser usado para depurar fluxos de trabalho PowerShell, quer na consola PowerShell, quer no Windows PowerShell ISE. A partir de PowerShell 5.0, você pode depurar dentro de trabalhos ou processos de execução, localmente ou remotamente.

Pode utilizar as características do depurar PowerShell para examinar um script, função, comando, fluxo de trabalho ou expressão do PowerShell durante o processo. O depurador PowerShell inclui um conjunto de cmdlets que permitem definir pontos de rutura, gerir pontos de rutura e ver a pilha de chamadas.

Comandantes Debugger

O depurador PowerShell inclui o seguinte conjunto de cmdlets:

Set-PSBreakpoint: Define pontos de rutura em linhas, variáveis e comandos.
Get-PSBreakpoint: Obtém pontos de rutura na sessão atual.
Disable-PSBreakpoint: Desliga os pontos de rutura na sessão atual.
Enable-PSBreakpoint: Reesibiliste pontos de rutura na sessão atual.
Remove-PSBreakpoint: Elimina pontos de rutura da sessão atual.
Get-PSCallStack: Exibe a pilha de chamadas atual.

Começando e parando o Debugger

Para iniciar o depurar, desembaraça um ou mais pontos de rutura. Em seguida, executar o script, o comando ou a função que pretende depurar.

Quando se chega a um ponto de rutura, a execução para e o controlo é entregue ao depurado.

Para parar o depurar, executar o script, o comando ou a função até estar completo. Ou, tipo stop t ou.

Comandos Debugger

Quando utilizar o depurador na consola PowerShell, utilize os seguintes comandos para controlar a execução. No Windows PowerShell ISE, utilize comandos no menu Debug.

Nota: Para obter informações sobre como utilizar o depurar noutras aplicações de anfitrião, consulte a documentação da aplicação do anfitrião.

s, StepInto Executa a próxima declaração e, em seguida, para.
v, StepOver : Executa a próxima declaração, mas ignora funções e invocações. As declarações ignoradas são executadas, mas não pisadas.
Ctrl+Break: (Break All in ISE) Divide-se num script de execução dentro da consola PowerShell ou do Windows PowerShell ISE. Note que ctrl + Break no Windows PowerShell 2.0, 3.0 e 4.0 fecha o programa. Break All funciona em scripts locais e remotos interativos.
o, StepOut : Sai da função atual; sobe um nível se aninhado. Se no corpo principal, continua até ao fim ou ao próximo ponto de rutura. As declarações ignoradas são executadas, mas não pisadas.
c, Continue : Continua a correr até que o guião esteja completo ou até que o próximo ponto de rutura seja atingido. As declarações ignoradas são executadas, mas não pisadas.
l, List : Exibe a parte do guião que está a ser executada. Por predefinição, apresenta a linha atual, cinco linhas anteriores e 10 linhas subsequentes. Para continuar a listar o script, prima ENTER.
l <m>, List : Apresenta 16 linhas do guião a começar pelo número de linha especificado por <m> .
l <m> <n>, List : Exibe <n> linhas do guião, a começar pelo número de linha especificado por <m> .
q``Stop, Exit , : Para de executar o guião e sai do depurante. Se estiver a depurar um trabalho com o Debug-Job comandante, o Exit comando desprende o depurante e permite que o trabalho continue a funcionar.
k, Get-PsCallStack : Exibe a pilha de chamadas atual.
<Enter>: Repete o último comando se for Step (s), StepOver (v) ou List (l). Caso contrário, representa uma ação de submissão.
?, h : Exibe a ajuda de comando de depurado.

Para sair do depurar, pode utilizar Stop (q).

A partir do PowerShell 5.0, pode executar o comando Exit para sair de uma sessão de depuragem aninhada que começou por executar Debug-Job ou Debug-Runspace .

Ao utilizar estes comandos de depurar, pode executar um script, parar num ponto de preocupação, examinar os valores das variáveis e o estado do sistema, e continuar a executar o script até identificar um problema.

NOTA: Se entrar numa declaração com um operador de reorientação, como ">", o depurgger PowerShell pisa todas as declarações restantes no script.

Exibindo os Valores das Variáveis de Script

Enquanto estiver no depurado, também pode introduzir comandos, mostrar o valor das variáveis, usar cmdlets e executar scripts na linha de comando.

Pode apresentar o valor atual de todas as variáveis no script que está a ser depurado, exceto para as seguintes variáveis automáticas:

$_
$Args
$Input
$MyInvocation
$PSBoundParameters

Se tentar mostrar o valor de qualquer uma destas variáveis, obtém-se o valor dessa variável para num oleoduto interno que o depurar utiliza, e não o valor da variável no script.

Para mostrar o valor destas variáveis para o script que está a ser depurado, no script, atribua o valor da variável automática a uma nova variável. Em seguida, pode mostrar o valor da nova variável.

Por exemplo,

$scriptArgs = $Args
$scriptArgs

No exemplo deste tópico, o valor da $MyInvocation variável é reatribuído da seguinte forma:

$scriptname = $MyInvocation.MyCommand.Path

O Ambiente Debugger

Quando se chega a um ponto de rutura, entra-se no ambiente de depuração. O comando muda de modo a começar com "[DBG]:". Se estiver a depurar um fluxo de trabalho, o pedido é "[WFDBG]". Pode personalizar a solicitação.

Para obter mais informações sobre a personalização do pedido, consulte about_Prompts.

Além disso, em algumas aplicações hospedeiras, como a consola PowerShell (mas não no Windows PowerShell Integrated Scripting Environment [ISE]), abre-se um pedido aninhado para depurar. Pode detetar a solicitação aninhada repetindo caracteres maiores do que os caracteres (ASCII 62) que aparecem na origem do comando.

Por exemplo, o seguinte é o pedido de depuração padrão na consola PowerShell:

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

Pode encontrar o nível de nidificação utilizando a $NestedPromptLevel variável automática.

Adicionalmente, uma variável $PSDebugContext automática, é definida no âmbito local. Pode utilizar a presença da $PsDebugContext variável para determinar se está no depurador.

Por exemplo:

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

Pode utilizar o valor da $PSDebugContext variável na sua depuragem.

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

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

Depuragem e Âmbito

Entrar no depurgger não altera o âmbito em que está a operar, mas quando se chega a um ponto de rutura num script, passa-se para o âmbito do script. O âmbito do guião é uma criança do âmbito em que executou o depurar.

Para encontrar as variáveis e pseudónimos definidos no âmbito do script, utilize o parâmetro Scope dos Get-Alias Get-Variable cmdlets ou cmdlets.

Por exemplo, o seguinte comando obtém as variáveis no âmbito local (script):

Get-Variable -scope 0

Pode abreviar o comando como:

gv -s 0

Esta é uma forma útil de ver apenas as variáveis que definiu no script e que definiu enquanto depurava.

Depurando na Linha de Comando

Quando definir um ponto de rutura variável ou um ponto de rutura de comando, pode definir o ponto de rutura apenas num ficheiro de script. No entanto, por padrão, o ponto de rutura está definido em qualquer coisa que seja executado na sessão atual.

Por exemplo, se definir um ponto de rutura $name na variável, o depurativo quebra qualquer $name variável em qualquer script, comando, função, cmdlet de script ou expressão que execute até desativar ou remover o ponto de rutura.

Isto permite-lhe depurar os seus scripts num contexto mais realista, no qual podem ser afetados por funções, variáveis e outros scripts na sessão e no perfil do utilizador.

Os pontos de rutura de linha são específicos dos ficheiros do script, pelo que são definidos apenas em ficheiros de scripts.

Depurando fluxos de trabalho

O depurar PowerShell 4.0 pode ser utilizado para depurar fluxos de trabalho PowerShell, quer na consola PowerShell, quer no Windows PowerShell ISE. Existem algumas limitações com a utilização do depurar PowerShell para depurar fluxos de trabalho.

Pode ver variáveis de fluxo de trabalho enquanto estiver no depurar, mas definir variáveis de fluxo de trabalho a partir do interior do depurado não é suportado.
A conclusão do separador quando parado no depurar de fluxo de trabalho não está disponível.
A depuragem do fluxo de trabalho funciona apenas com o funcionamento sincronizado de fluxos de trabalho a partir de um script PowerShell. Não é possível depurar fluxos de trabalho se estiverem a funcionar como um trabalho (com o parâmetro AsJob).
Outros cenários de depurações aninhados, como um fluxo de trabalho chamado outro fluxo de trabalho ou um fluxo de trabalho chamado de script, não são implementados.

O exemplo a seguir demonstra a depuragem de um fluxo de trabalho. Quando o depurador entra na função de fluxo de trabalho, o 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:"
# +!INCLUDE[]~~~~~

[WFDBG:localhost]: PS C:>> list

# 3:

4:  workflow SampleWorkflowTest
5:  {
6:      param ($MyOutput)
# 7:

8:*     Write-Output -InputObject "Now writing output:"
9:      Write-Output -Input $MyOutput
# 10:

11:      Write-Output -InputObject "Get PowerShell process:"
12:      Get-Process -Name powershell
# 13:

14:      Write-Output -InputObject "Workflow function complete."
15:  }
# 16:

17:  # Call workflow function
18:  SampleWorkflowTest -MyOutput "Hello"

[WFDBG:localhost]: PS C:>> $MyOutput
Hello
[WFDBG:localhost]: PS C:>> stepOver
Now writing output:
At C:\TestWFDemo1.ps1:9 char:5
+     Write-Output -Input $MyOutput
# +!INCLUDE[]~

[WFDBG:localhost]: PS C:>> list

4:  workflow SampleWorkflowTest
5:  {
6:      param ($MyOutput)
# 7:

8:      Write-Output -InputObject "Now writing output:"
9:*     Write-Output -Input $MyOutput
# 10:

11:      Write-Output -InputObject "Get PowerShell process:"
12:      Get-Process -Name powershell
# 13:

14:      Write-Output -InputObject "Workflow function complete."
15:  }
# 16:

17:  # Call workflow function
18:  SampleWorkflowTest -MyOutput "Hello"
# 19:


[WFDBG:localhost]: PS C:>> stepOver
Hello
At C:\TestWFDemo1.ps1:11 char:5
+     Write-Output -InputObject "Get PowerShell process:"
# +!INCLUDE[]~~~~~~~~~

[WFDBG:localhost]: PS C:>> stepOut
Get PowerShell process:

Handles  NPM(K)    PM(K)    WS(K) VM(M)   CPU(s)     Id ProcessName
-------  ------    -----    ----- -----   ------     -- -----------
    433      35   106688   128392   726     2.67   7124 powershell
    499      44   134244   172096   787     2.79   7452 powershell

Workflow function complete.

Funções de depurar

Quando se define um ponto de rutura numa função que Begin Process tem, e End secções, o depurador quebra-se na primeira linha de cada secçã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>

Depurando scripts remotos

A partir do PowerShell 5.0, pode executar o depurante PowerShell numa sessão remota, quer na consola, quer no Windows PowerShell ISE. Enter-PSSessiona funcionalidade foi atualizada para permitir que volte a ligar-se e introduzir uma sessão desligada que esteja a ser executada num computador remoto e que atualmente executa um script. Se o script de execução atingir um ponto de rutura, a sessão do seu cliente inicia automaticamente o depuração.

Segue-se um exemplo que mostra como isto funciona, com breakpoints definidos num roteiro nas linhas 6, 11, 22 e 25. Note que no exemplo, quando o depurante começa, existem duas indicações de identificação: o nome do computador em que a sessão está a decorrer, e o dBG que lhe permite saber que está em modo de depuramento.

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

Este script de teste deteta a versão do sistema operativo e apresenta uma mensagem apropriada para o sistema. Inclui uma função, uma chamada de função e uma variável.

O seguinte comando mostra o conteúdo do ficheiro do script de teste:

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."

Para começar, desaponte um ponto de rutura num ponto de interesse no script, como uma linha, comando, variável ou função.

Comece por criar um ponto de rutura de linha na primeira linha do script Test.ps1 no diretório atual.

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

Pode abreviar este comando como:

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

O comando devolve um objeto de quebra de linha (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, começa o guião.

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

Quando o script atinge o primeiro ponto de rutura, a mensagem de breakpoint indica que o depurador está ativo. Descreve o breakpoint e pré-visualiza a primeira linha do script, que é uma declaração de função. O pedido de comando também muda para indicar que o depurador tem controlo.

A linha de pré-visualização inclui o nome do guião e o número de linha do comando pré-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>

Utilize o (s) comando (s) step (s) para executar a primeira declaração no script e para visualizar a próxima declaração. A próxima declaração utiliza a $MyInvocation variável automática para definir o valor da $scriptName variável para o caminho e nome do ficheiro do ficheiro.

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

Neste ponto, a $scriptName variável não é povoada, mas pode verificar o valor da variável exibindo o seu valor. Neste caso, o valor $null é.

DBG> $scriptname
# DBG>

Utilize outro (s) comando (s) passo para executar a declaração atual e para visualizar a próxima declaração no script. A próxima declaração chama a função PsVersion.

DBG> s
test.ps1:12  psversion

Neste ponto, a $scriptName variável é povoada, mas você verifica o valor da variável exibindo o seu valor. Neste caso, o valor é definido para o caminho do script.

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

Utilize outro comando Step para executar a chamada de função. Prima ENTER, ou escreva "s" para Step.

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

A mensagem de depurg inclui uma pré-visualização da declaração na função. Para executar esta declaração e para visualizar a próxima declaração na função, pode utilizar um Step comando. Mas, neste caso, use um comando StepOut (o). Completa a execução da função (a menos que atinja um ponto de rutura) e passos para a próxima declaração no script.

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

Porque estamos na última declaração no script, os comandos Step, StepOut e Continue têm o mesmo efeito. Neste caso, utilize StepOut (o).

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

O comando StepOut executa o último comando. A indicação de comando padrão indica que o depurado saiu e devolveu o controlo ao processador de comando.

Agora, corre o depurar outra vez. Primeiro, para eliminar o ponto de rutura atual, utilize os Get-PsBreakpoint Remove-PsBreakpoint cmdlets e os cmdlets. (Se acha que pode reutilizar o ponto de rutura, use o Disable-PsBreakpoint cmdlet em vez de Remove-PsBreakpoint .)

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

Pode abreviar este comando como:

PS C:\ps-test> gbp | rbp

Ou, executar o comando escrevendo uma função, tal como a seguinte função:

function delbr { gbp | rbp }

Agora, crie um ponto de rutura na $scriptname variável.

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

Pode abreviar o comando como:

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

Agora, começa o guião. O script atinge o ponto de rutura variável. O modo predefinido é Escrever, pelo que a execução para pouco antes da declaraçã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>

Mostrar o valor atual da $scriptName variável, que é $null .

DBG> $scriptName
# DBG>

Utilize um (s) comando (s) passo para executar a declaração que povoa a variável. Em seguida, mostrar o novo valor da $scriptName variável.

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

A próxima declaração é uma chamada para a função PsVersion. Para saltar a função mas ainda executá-la, utilize um comando StepOver (v). Se já estiver na função quando utilizar o StepOver, não é eficaz. A chamada de função é exibida, mas não é executada.

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

O comando StepOver executa a função e pré-visualiza a próxima declaração no script, que imprime a linha final.

Utilize um comando Stop (t) para sair do depurado. O pedido de comando reverte para a pressão de comando padrão.

C:\ps-test>

Para eliminar os pontos de rutura, utilize os Get-PsBreakpoint Remove-PsBreakpoint cmdlets e os cmdlets.

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

Crie um novo ponto de rutura de comando na função PsVersion.

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

Pode abreviar este comando para:

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

Agora, executar o guião.

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 rutura na chamada de função. Neste momento, a função ainda não foi chamada. Isto dá-lhe a oportunidade de utilizar o parâmetro de Ação para Set-PSBreakpoint definir condições para a execução do ponto de rutura ou para executar tarefas preparatórias ou de diagnóstico, tais como iniciar um registo ou invocar um script de diagnóstico ou segurança.

Para definir uma ação, utilize um comando Continue (c) para sair do script e um Remove-PsBreakpoint comando para eliminar o ponto de rutura atual. (Os pontos de rutura são apenas de leitura, pelo que não é possível adicionar uma ação ao ponto de rutura 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 rutura de comando com uma ação. O comando a seguir define um ponto de rutura de comando com uma ação que regista o valor da $scriptName variável quando a função é chamada. Como a palavra-chave Break não é utilizada na ação, a execução não para. (O retrocesso (') é o personagem de continuação da linha.)

PS C:\ps-test> Set-PSBreakpoint -command psversion -script test.ps1  `
-action { add-content "The value of `$scriptName is $scriptName." `
-path action.log}

Também pode adicionar ações que estabeleçam condições para o ponto de rutura. No comando seguinte, o ponto de rutura de comando só é executado se a política de execução for definida como RemoteSigned, a política mais restritiva que ainda lhe permite executar scripts. (O retrocesso (') é o personagem da continuação.)

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

A palavra-chave Break na ação direciona o depurador para executar o ponto de rutura. Também pode utilizar a palavra-chave Continuar para direcionar o depurar para executar sem quebrar. Como a palavra-chave predefinida é Continuar, tem de especificar Break para parar a execução.

Agora, executar o guião.

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

test.ps1:12  psversion

Como a política de execução está definida para RemoteSigned, a execução para na chamada de função.

Neste momento, talvez queira verificar a pilha de chamadas. Utilize o Get-PsCallStack comandante ou o comando de Get-PsCallStack depurado (k). O seguinte comando recebe a pilha de chamadas atual.

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

Este exemplo demonstra apenas algumas das muitas formas de usar o depurar PowerShell.

Para obter mais informações sobre os cmdlets de depurado, digite o seguinte comando:

help <cmdlet-name> -full

Por exemplo, escreva:

help Set-PSBreakpoint -full

Outras funcionalidades de depuragem em PowerShell

Além do depurar PowerShell, o PowerShell inclui várias outras funcionalidades que podes usar para depurar scripts e funções.

O Windows PowerShell ISE inclui um depurativo gráfico interativo. Para mais informações, inicie o Windows PowerShell ISE e prima F1.
O Set-PSDebug cmdlet oferece características de depuragem de scripts muito básicas, incluindo pisar e rastrear.
Utilize o Set-StrictMode cmdlet para detetar referências a variáveis não-iniializadas, a referências a propriedades inexistentes de um objeto, e a funcionar sintaxe que não é válida.
Adicione declarações de diagnóstico a um script, tais como declarações que mostram o valor das variáveis, declarações que lêem a entrada da linha de comando, ou declarações que reportam a instrução atual. Utilize os cmdlets que contêm o verbo Write para esta tarefa, tais como Write-Host Write-Debug , , e Write-Warning Write-Verbose .

VER TAMBÉM

Last updated on 2019-08-06

Partilhar via