Sdílet prostřednictvím

O ladicích programech

KRÁTKÝ POPIS

Popisuje ladicí program PowerShellu.

DLOUHÝ POPIS

Ladění je proces zkoumání skriptu za běhu za účelem identifikace a opravy chyb v pokynech ke skriptu. Ladicí program PowerShellu vám může pomoci prozkoumat a identifikovat chyby a neefektivitu ve skriptech, funkcích, příkazech, pracovních postupech PowerShellu, konfiguracích DSC (PowerShell Desired State Configuration) nebo výrazech.

Počínaje PowerShellem 5.0 byl ladicí program PowerShellu aktualizován tak, aby ladil skripty, funkce, pracovní postupy, příkazy, konfigurace nebo výrazy, které běží buď v konzole, nebo v Integrované skriptovací prostředí (ISE) v prostředí Windows PowerShell na vzdálených počítačích. Spuštěním Enter-PSSession můžete spustit interaktivní vzdálenou relaci PowerShellu, ve které můžete nastavit zarážky a ladit soubory a příkazy skriptu na vzdáleném počítači. Enter-PSSession Funkce byla aktualizována tak, aby umožňovala opětovné připojení a zadání odpojené relace, ve které je spuštěn skript nebo příkaz ve vzdáleném počítači. Pokud spuštěný skript dosáhne zarážky, relace klienta automaticky spustí ladicí program. Pokud odpojená relace, na které je spuštěn skript, již dosáhla zarážky a je zastavena na této zarážce, Enter-PSSession automaticky spustí ladicí program příkazového řádku po opětovném připojení k relaci.

Ladicí program PowerShellu je také možné použít k ladění pracovních postupů PowerShellu, a to buď v konzole PowerShellu, nebo v Integrované skriptovací prostředí (ISE) v prostředí Windows PowerShell. Od PowerShellu 5.0 můžete ladit v rámci spuštěných úloh nebo procesů, a to buď místně, nebo vzdáleně.

Funkce ladicího programu PowerShell můžete použít k prozkoumání skriptu, funkce, příkazu, pracovního postupu nebo výrazu PowerShellu, když je spuštěný. Ladicí program PowerShell obsahuje sadu rutin, které umožňují nastavovat zarážky, spravovat zarážky a zobrazovat zásobník volání.

Rutiny ladicího programu

Ladicí program PowerShellu obsahuje následující sadu rutin:

  • Set-PSBreakpoint: Nastaví zarážky na řádcích, proměnných a příkazech.
  • Get-PSBreakpoint: Získá zarážky v aktuální relaci.
  • Disable-PSBreakpoint: Vypne zarážky v aktuální relaci.
  • Enable-PSBreakpoint: Znovu povolí zarážky v aktuální relaci.
  • Remove-PSBreakpoint: Odstraní zarážky z aktuální relace.
  • Get-PSCallStack: Zobrazí aktuální zásobník volání.

Spuštění a zastavení debuggeru

Chcete-li spustit ladicí program, nastavte jednu nebo více zarážek. Poté spusťte skript, příkaz nebo funkci, kterou chcete ladit.

Když dosáhnete zarážky, spuštění se zastaví a ovládací prvek se převrátí do ladicího programu.

Chcete-li ladicí program zastavit, spusťte skript, příkaz nebo funkci, dokud nebude dokončen. Nebo zadejte stop nebo t.

Příkazy ladicího programu

Při použití ladicího programu v konzole PowerShellu použijte následující příkazy k řízení provádění. V prostředí Windows PowerShell ISE použijte příkazy v nabídce Ladění.

Poznámka: Informace o tom, jak používat ladicí program v jiných hostitelských aplikacích, naleznete v dokumentaci k hostitelské aplikaci.

  • s, StepInto: Spustí další příkaz a pak se zastaví.

  • v, StepOver: Spustí další příkaz, ale přeskočí funkce a vyvolání. Přeskočené příkazy se spustí, ale neprojdou.

  • Ctrl+Break: (Break All in ISE) Rozdělí do spuštěného skriptu v konzole PowerShellu nebo prostředí Windows PowerShell ISE. Všimněte si, že Ctrl+Break v prostředí Windows PowerShell 2.0, 3.0 a 4.0 program zavře. Break All funguje na místních i vzdálených interaktivně spuštěných skriptech.

  • o, StepOut: Kroky z aktuální funkce; o jednu úroveň výš, pokud je vnořená. Pokud je v hlavním těle, pokračuje na konec nebo další zarážku. Přeskočené příkazy se spustí, ale neprojdou.

  • c, Continue: Pokračuje ve spuštění, dokud se skript nedokončí nebo dokud se nedosáhne další zarážky. Přeskočené příkazy se spustí, ale neprojdou.

  • l, List: Zobrazí část skriptu, která se provádí. Ve výchozím nastavení zobrazuje aktuální řádek, pět předchozích řádků a 10 dalších řádků. Pokud chcete pokračovat v výpisu skriptu, stiskněte enter.

  • l <m>, List: Zobrazí 16 řádků skriptu začínajícího číslem řádku určeným <m>.

  • l <m> <n>, List: Zobrazí <n> řádky skriptu počínaje číslem řádku určeným <m>.

  • q, Stop, Exit: Zastaví spuštění skriptu a ukončí ladicí program. Pokud ladíte úlohu spuštěním rutiny Debug-Job, příkaz Exit odpojí ladicí program a umožní úlohu pokračovat ve spuštění.

  • k, Get-PsCallStack: Zobrazí aktuální zásobník volání.

  • <Enter>: Opakuje poslední příkaz, pokud to byl Krok (s), KrokPřesah (v) nebo Seznam (l). V opačném případě představuje akci odeslání.

  • ?, h: Zobrazí nápovědu k příkazu ladicího programu.

Chcete-li ladicí program ukončit, můžete použít příkaz Stop (q).

Počínaje PowerShellem 5.0 můžete spuštěním příkazu Exit ukončit vnořenou relaci ladění, kterou jste spustili spuštěním Debug-Job nebo Debug-Runspace.

Pomocí těchto příkazů ladicího programu můžete spustit skript, zastavit se na problematickém místě, prozkoumat hodnoty proměnných a stav systému a pokračovat v běhu skriptu, dokud nezjistíte problém.

POZNÁMKA: Pokud vstoupíte do příkazu s operátorem přesměrování, například ">", ladicí program PowerShell přejde přes všechny zbývající příkazy ve skriptu.

Zobrazení hodnot proměnných skriptu

V ladicím programu můžete také zadat příkazy, zobrazit hodnotu proměnných, používat rutiny a spouštět skripty na příkazovém řádku.

V laděném skriptu můžete zobrazit aktuální hodnotu všech proměnných, s výjimkou následujících automatických proměnných:

$_
$Args
$Input
$MyInvocation
$PSBoundParameters

Pokud se pokusíte zobrazit hodnotu kterékoli z těchto proměnných, získáte hodnotu této proměnné v interním kanálu, který ladicí program používá, nikoli hodnotu proměnné ve skriptu.

Chcete-li zobrazit hodnotu těchto proměnných pro skript, který je laděn, ve skriptu přiřaďte hodnotu automatické proměnné nové proměnné. Pak můžete zobrazit hodnotu nové proměnné.

Příklad:

$scriptArgs = $Args
$scriptArgs

V příkladu v tomto tématu je hodnota proměnné znovu přiřazena $MyInvocation následujícím způsobem:

$scriptname = $MyInvocation.MyCommand.Path

Prostředí ladicího programu

Když dosáhnete zarážky, zadáte prostředí ladicího programu. Příkazový řádek se změní tak, aby začal na "[DBG]:". Pokud ladíte pracovní postup, zobrazí se výzva "[WFDBG]". Výzvu můžete přizpůsobit.

Další informace o přizpůsobení výzvy naleznete v tématu about_Prompts.

V některých hostitelských aplikacích, jako je konzola PowerShell (ale ne v prostředí ISE (Windows PowerShell Integrated Scripting Environment), se také otevře vnořená výzva pro ladění. Vnořenou výzvu můžete zjistit opakováním znaků větších než (ASCII 62), které se zobrazí na příkazovém řádku.

Výchozí výzva k ladění v konzole PowerShell je například následující:

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

Úroveň vnoření najdete pomocí $NestedPromptLevel automatické proměnné.

Kromě toho je v místním rozsahu definována automatická proměnná $PSDebugContext, . Přítomnost proměnné $PsDebugContext můžete použít k určení, zda jste v ladicím programu.

Například:

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

V ladění můžete použít hodnotu proměnné $PSDebugContext.

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

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

Ladění a rozsah

Přerušení do ladicího programu nezmění rozsah, ve kterém pracujete, ale když dosáhnete zarážky ve skriptu, přesunete se do oboru skriptu. Obor skriptu je podřízený obor, ve kterém jste spustili ladicí program.

K vyhledání proměnných a aliasů definovaných v oboru skriptu použijte parametr Scope Get-Alias nebo Get-Variable rutin.

Například následující příkaz získá proměnné v oboru místního (skriptu):

Get-Variable -scope 0

Příkaz můžete zkrátit takto:

gv -s 0

To je užitečný způsob, jak zobrazit pouze proměnné, které jste definovali ve skriptu a které jste definovali při ladění.

Ladění na příkazovém řádku

Když nastavíte zarážku proměnné nebo zarážku příkazu, můžete zarážku nastavit pouze v souboru skriptu. Ve výchozím nastavení je ale zarážka nastavená na cokoli, co se spouští v aktuální relaci.

Pokud například nastavíte zarážku na proměnné $name, ladicí program se přeruší u libovolné proměnné $name v libovolném skriptu, příkazu, funkci, rutině skriptu nebo výrazu, který spustíte, dokud nezakážete nebo neodeberete zarážku.

To vám umožní ladit skripty v realističtějším kontextu, ve kterém mohou být ovlivněny funkcemi, proměnnými a dalšími skripty v relaci a v profilu uživatele.

Zarážky řádků jsou specifické pro soubory skriptů, takže se nastavují pouze v souborech skriptů.

Ladění pracovních postupů

Ladicí program PowerShellu 4.0 je možné použít k ladění pracovních postupů PowerShellu, a to buď v konzole PowerShellu, nebo v Integrované skriptovací prostředí (ISE) v prostředí Windows PowerShell. Použití ladicího programu PowerShellu k ladění pracovních postupů má určitá omezení.

  • Proměnné pracovního postupu můžete zobrazit v ladicím programu, ale nastavení proměnných pracovního postupu z ladicího programu není podporováno.
  • Dokončování tabulátoru při zastavení v ladicím programu pracovního postupu není k dispozici.
  • Ladění pracovního postupu funguje pouze se synchronním spouštěním pracovních postupů ze skriptu PowerShellu. Pracovní postupy nelze ladit, pokud jsou spuštěny jako úloha (s parametrem AsJob ).
  • Jiné vnořené scénáře ladění, jako je například pracovní postup volající jiný pracovní postup nebo pracovní postup volající skript, nejsou implementovány.

Následující příklad ukazuje ladění pracovního postupu. Když ladicí program přejde do funkce pracovního postupu, výzva ladicího programu se změní na "[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.

Ladění funkcí

Když nastavíte zarážku na funkci, která má Begin, Processa End oddílů, ladicí program se přeruší na prvním řádku každého oddílu.

Například:

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>

Ladění vzdálených skriptů

Počínaje PowerShellem 5.0 můžete ladicí program PowerShellu spustit ve vzdálené relaci, a to buď v konzole, nebo v Integrované skriptovací prostředí (ISE) v prostředí Windows PowerShell. Enter-PSSession Funkce byla aktualizována tak, aby umožňovala znovu se připojit k odpojené relaci, která je spuštěna na vzdáleném počítači a aktuálně spuštěn skript, a zadat ji. Pokud spuštěný skript dosáhne zarážky, relace klienta automaticky spustí ladicí program.

Následuje příklad, který ukazuje, jak to funguje, se zarážkami nastavenými ve skriptu na řádcích 6, 11, 22 a 25. Všimněte si, že v tomto příkladu jsou při spuštění ladicího programu dvě identifikační výzvy: název počítače, na kterém je relace spuštěna, a výzva DBG, která vás informuje, že jste v režimu ladě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>

Příklady

Tento testovací skript zjistí verzi operačního systému a zobrazí zprávu odpovídající systému. Zahrnuje funkci, volání funkce a proměnnou.

Následující příkaz zobrazí obsah souboru testovacího skriptu:

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

Začněte tím, že nastavíte zarážku v okamžiku zájmu ve skriptu, například řádek, příkaz, proměnnou nebo funkci.

Začněte vytvořením zarážky řádku na prvním řádku skriptu Test.ps1 v aktuálním adresáři.

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

Tento příkaz můžete zkrátit takto:

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

Příkaz vrátí objekt zarážky řádku (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

Teď spusťte skript.

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

Když skript dosáhne první zarážky, zpráva zarážky indikuje, že ladicí program je aktivní. Popisuje zarážku a zobrazí náhled prvního řádku skriptu, což je deklarace funkce. Příkazový řádek se také změní, aby indikoval, že ladicí program má ovládací prvek.

Řádek náhledu obsahuje název skriptu a číslo řádku náhledu příkazu.

Entering debug mode. Use h or ? for help.

Hit Line breakpoint on 'C:\ps-test\test.ps1:1'

test.ps1:1   function psversion {
# DBG>

Pomocí příkazu Step (s) spusťte první příkaz ve skriptu a zobrazte náhled dalšího příkazu. Další příkaz používá $MyInvocation automatickou proměnnou k nastavení hodnoty proměnné $scriptName na cestu a název souboru skriptu.

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

V tomto okamžiku není proměnná $scriptName vyplněna, ale hodnotu proměnné můžete ověřit zobrazením její hodnoty. V tomto případě je $nullhodnota .

DBG> $scriptname
# DBG>

Pomocí dalšího příkazu (příkazů) Step proveďte aktuální příkaz a zobrazte náhled dalšího příkazu ve skriptu. Další příkaz volá funkci PsVersion.

DBG> s
test.ps1:12  psversion

V tomto okamžiku se naplní proměnná $scriptName, ale hodnotu proměnné ověříte zobrazením její hodnoty. V tomto případě je hodnota nastavena na cestu skriptu.

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

K provedení volání funkce použijte jiný příkaz Krok. Stiskněte ENTER nebo zadejte "s" pro krok.

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

Ladicí zpráva obsahuje náhled příkazu ve funkci. Pokud chcete tento příkaz spustit a zobrazit náhled dalšího příkazu ve funkci, můžete použít příkaz Step. V tomto případě ale použijte příkaz StepOut (o). Dokončí provádění funkce (pokud nedosáhne zarážky) a kroky k dalšímu příkazu ve skriptu.

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

Protože se nacházíme u posledního příkazu ve skriptu, příkazy Step, StepOut a Continue mají stejný účinek. V tomto případě použijte StepOut (o).

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

Příkaz StepOut spustí poslední příkaz. Standardní příkazový řádek označuje, že ladicí program ukončil a vrátil ovládací prvek do procesoru příkazů.

Teď znovu spusťte ladicí program. Nejprve k odstranění aktuální zarážky použijte rutiny Get-PSBreakpoint a Remove-PSBreakpoint. (Pokud si myslíte, že byste mohli zarážku znovu použít, použijte místo Disable-PSBreakpointrutinu Remove-PSBreakpoint.)

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

Tento příkaz můžete zkrátit takto:

PS C:\ps-test> gbp | rbp

Nebo spusťte příkaz napsáním funkce, například následující funkce:

function delbr { gbp | rbp }

Teď vytvořte zarážku v proměnné $scriptname.

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

Příkaz můžete zkrátit takto:

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

Teď spusťte skript. Skript dosáhne zarážky proměnné. Výchozí režim je Write, takže provádění se zastaví těsně před příkazem, který změní hodnotu proměnné.

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>

Zobrazí aktuální hodnotu proměnné $scriptName, která je $null.

DBG> $scriptName
# DBG>

Pomocí příkazu (příkazů) Step proveďte příkaz, který naplní proměnnou. Pak zobrazte novou hodnotu proměnné $scriptName.

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

Dalším příkazem je volání funkce PsVersion. Chcete-li funkci přeskočit, ale přesto ji provést, použijte příkaz StepOver (v). Pokud jste již ve funkci při použití funkce StepOver, není to efektivní. Volání funkce je zobrazeno, ale není provedeno.

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

Příkaz StepOver provede funkci a ve skriptu zobrazí náhled dalšího příkazu, který vytiskne poslední řádek.

Pomocí příkazu Stop (t) ukončete ladicí program. Příkazový řádek se vrátí na standardní příkazový řádek.

C:\ps-test>

K odstranění zarážek použijte rutiny Get-PSBreakpoint a Remove-PSBreakpoint.

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

Vytvořte novou zarážku příkazu ve funkci PsVersion.

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

Tento příkaz můžete zkrátit na:

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

Teď spusťte skript.

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

test.ps1:12  psversion
# DBG>

Skript dosáhne zarážky při volání funkce. V tuto chvíli ještě nebyla funkce volána. Díky tomu můžete pomocí parametru Akce Set-PSBreakpoint nastavit podmínky pro spuštění zarážky nebo provádět přípravné nebo diagnostické úlohy, jako je spuštění protokolu nebo vyvolání diagnostického nebo bezpečnostního skriptu.

Pokud chcete nastavit akci, pomocí příkazu Pokračovat (c) ukončete skript a příkaz Remove-PSBreakpoint k odstranění aktuální zarážky. (Zarážky jsou jen pro čtení, takže k aktuální zarážce nemůžete přidat akci.)

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>

Teď vytvořte novou zarážku příkazu pomocí akce. Následující příkaz nastaví zarážku příkazu s akcí, která zaznamená hodnotu proměnné $scriptName při zavolání funkce. Vzhledem k tomu, že klíčové slovo Break není v akci použito, provádění se nezastaví. (Značka backtick (') je znak pro pokračování řádku.)

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

Můžete také přidat akce, které nastaví podmínky pro zarážku. V následujícím příkazu se zarážka příkazu spustí pouze v případě, že je zásada spouštění nastavena na RemoteSigned, nejvíce omezující zásady, které vám stále umožňují spouštět skripty. (Značka backtick (') je znak pokračování.)

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

Klíčové slovo Break v akci nasměruje ladicí program ke spuštění zarážky. Můžete také použít klíčové slovo Continue k nasměrování ladicího programu tak, aby se spustil bez přerušení. Vzhledem k tomu, že výchozí klíčové slovo je Continue, je nutné zadat Break pro zastavení provádění.

Teď spusťte skript.

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

test.ps1:12  psversion

Vzhledem k tomu, že je zásada spuštění nastavena na RemoteSigned, provádění se zastaví při volání funkce.

V tuto chvíli můžete chtít zkontrolovat zásobník volání. Použijte rutinu Get-PsCallStack nebo příkaz ladicího Get-PsCallStack programu (k). Následující příkaz získá aktuální zásobník volání.

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

Tento příklad ukazuje jen několik z mnoha způsobů použití ladicího programu PowerShellu.

Chcete-li získat další informace o rutinách ladicího programu, zadejte následující příkaz:

help <cmdlet-name> -full

Zadejte například:

help Set-PSBreakpoint -full

Další funkce ladění v PowerShellu

Kromě ladicího programu PowerShellu obsahuje PowerShell několik dalších funkcí, které můžete použít k ladění skriptů a funkcí.

  • Integrované skriptovací prostředí (ISE) v prostředí Windows PowerShell obsahuje interaktivní grafický ladicí program. Další informace získáte spuštěním Integrované skriptovací prostředí (ISE) v prostředí Windows PowerShell a stisknutím klávesy F1.

  • Rutina Set-PSDebug nabízí velmi základní funkce ladění skriptů, včetně krokování a trasování.

  • Pomocí rutiny Set-StrictMode můžete zjistit odkazy na neinicializované proměnné, na odkazy na neexistující vlastnosti objektu a na syntaxi funkce, která není platná.

  • Přidejte do skriptu diagnostické příkazy, například příkazy, které zobrazují hodnotu proměnných, příkazy, které čtou vstup z příkazového řádku, nebo příkazy, které hlásí aktuální instrukce. Použijte rutiny, které obsahují příkaz Write pro tento úkol, například Write-Host, Write-Debug, Write-Warninga Write-Verbose.

VIZ TAKÉ

  • Last updated on