Megosztás a következőn keresztül:

A debuggerek ismertetése

RÖVID LEÍRÁS

Ismerteti a PowerShell-hibakeresőt.

HOSSZÚ LEÍRÁS

A hibakeresés az a folyamat, amelynek során a parancsfájlok megvizsgálják a parancsfájl utasításait a hibák azonosításához és kijavításához. A PowerShell-hibakereső segítséget nyújt a parancsfájlok, függvények, parancsok, PowerShell-munkafolyamatok, a PowerShell kívánt állapot-konfiguráció (DSC) konfigurációjának vagy kifejezéseknek a hibáinak és hatékonyságának vizsgálatában és azonosításában.

A PowerShell 5,0-es verziójától kezdve a PowerShell-hibakereső frissült a konzolon vagy a Windows PowerShell integrált parancsprogram-kezelési környezet távoli számítógépeken futó parancsfájlok, függvények, munkafolyamatok, parancsok, konfigurációk vagy kifejezések hibakereséséhez. Futtathat Enter-PSSession egy interaktív távoli PowerShell-munkamenetet, amelyben töréspontokat és hibakeresési parancsfájlokat és parancsokat állíthat be a távoli számítógépen. Enter-PSSessiona funkció frissült, és megadható egy leválasztott munkamenet, amely parancsfájlt vagy parancsot futtat egy távoli számítógépen. Ha a futó parancsfájl töréspontot üt, az ügyfél-munkamenet automatikusan elindítja a hibakeresőt. Ha egy parancsfájlt futtató leválasztott munkamenet már elérte a töréspontot, és a töréspontnál leáll, a Enter-PSSession automatikusan elindítja a parancssori hibakeresőt, miután újrakapcsolódott a munkamenethez.

A PowerShell-hibakereső is használható PowerShell-munkafolyamatok hibakereséséhez a PowerShell-konzolon vagy Windows PowerShell integrált parancsprogram-kezelési környezet. A PowerShell 5,0-től kezdve a feladatok vagy folyamatok helyi vagy távoli futtatásával is hibakeresést végezhet.

A PowerShell-hibakereső funkciói segítségével megvizsgálhat egy PowerShell-parancsfájlt, függvényt, parancsot, munkafolyamatot vagy kifejezést a futása közben. A PowerShell-hibakereső olyan parancsmagokat tartalmaz, amelyek lehetővé teszik a töréspontok beállítását, a töréspontok kezelését és a hívási verem megtekintését.

Hibakereső parancsmagok

A PowerShell-hibakereső a következő parancsmagokat tartalmazza:

  • Set-PSBreakpoint: Töréspontokat állít be a vonalakon, a változókon és a parancsokon.
  • Get-PSBreakpoint: Töréspontokat kap az aktuális munkamenetben.
  • Disable-PSBreakpoint: Kikapcsolja a töréspontokat az aktuális munkamenetben.
  • Enable-PSBreakpoint: A töréspontok újbóli engedélyezése az aktuális munkamenetben.
  • Remove-PSBreakpoint: A töréspontok törlése az aktuális munkamenetből.
  • Get-PSCallStack: Az aktuális hívási verem megjelenítése.

A hibakereső elindítása és leállítása

A hibakereső elindításához állítson be egy vagy több töréspontot. Ezután futtassa a hibakereséshez használni kívánt parancsfájlt, parancsot vagy függvényt.

Amikor eléri a töréspontot, a végrehajtás leáll, és a vezérlő átvált a hibakeresőre.

A hibakereső leállításához futtassa a szkriptet, a parancsot vagy a függvényt egészen addig, amíg be nem fejeződik. Vagy írja be a következőt: stop vagy t .

Hibakereső parancsai

Ha a hibakeresőt a PowerShell-konzolon használja, a következő parancsokkal vezérelheti a végrehajtást. Windows PowerShell integrált parancsprogram-kezelési környezet a hibakeresés menüben használja a parancsokat.

Megjegyzés: a hibakereső más gazdagép alkalmazásokban való használatáról további információt a gazda alkalmazás dokumentációjában talál.

  • s, StepInto : Végrehajtja a következő utasítást, majd leállítja azt.

  • v, StepOver : Végrehajtja a következő utasítást, de kihagyja a függvényeket és a meghívásokat. A rendszer végrehajtja a kihagyott utasításokat, de nem hajtja végre.

  • Ctrl+Break: (Az ISE összes kibontása) a PowerShell-konzolon vagy Windows PowerShell integrált parancsprogram-kezelési környezeton belül egy futó parancsfájlba törik. Vegye figyelembe Ctrl, hogy a + Windows PowerShell 2,0-es, 3,0-as és 4,0-as verziójában a CTRLbreak a programot zárja le. Mind a helyi, mind a távoli, interaktívan futó parancsfájlokban egyaránt működik.

  • o, StepOut : Lépések a jelenlegi függvényből; egy szinttel feljebb, ha beágyazott. Ha a főtörzsben, az továbbra is a végére vagy a következő töréspontra mutat. A rendszer végrehajtja a kihagyott utasításokat, de nem hajtja végre.

  • c, Continue : Továbbra is fut, amíg a parancsfájl be nem fejeződik, vagy amíg a következő töréspont el nem éri. A rendszer végrehajtja a kihagyott utasításokat, de nem hajtja végre.

  • l, List : Megjeleníti a futtatott parancsfájl részét. Alapértelmezés szerint az aktuális sort, öt előző sort és 10 soron következő sort jeleníti meg. A parancsfájl listázásának folytatásához nyomja le az ENTER billentyűt.

  • l <m>, List : A parancsfájl 16 sorát jeleníti meg a által megadott sorszámmal kezdődően <m> .

  • l <m> <n>, List : <n> A parancsfájl sorait jeleníti meg, kezdve a által megadott sorszámmal <m> .

  • q, Stop , Exit : Leállítja a parancsfájl végrehajtását, és kilép a hibakeresőből. Ha a parancsmag futtatásával végzi a feladatok hibakeresését Debug-Job , a Exit parancs leválasztja a hibakeresőt, és lehetővé teszi, hogy a feladatok továbbra is fussanak.

  • k, Get-PsCallStack : Az aktuális hívási verem megjelenítése.

  • <Enter>: Megismétli az utolsó parancsot, ha a lépés (ek), a StepOver (v) vagy a List (l) volt. Ellenkező esetben egy küldési műveletet jelöl.

  • ?, h : Megjeleníti a hibakereső parancs súgóját.

A hibakeresőből való kilépéshez használhatja a Leállítás (q) lehetőséget.

A PowerShell 5,0-től kezdve a kilépési parancs futtatásával kiléphet egy, a vagy a futtatásával indított beágyazott hibakeresési munkamenetből Debug-Job Debug-Runspace .

A hibakereső parancsainak használatával futtathat egy parancsfájlt, leállíthatja a problémát, megvizsgálhatja a változók értékeit és a rendszer állapotát, és továbbra is futtathatja a parancsfájlt, amíg nem azonosított egy problémát.

Megjegyzés: Ha egy átirányítási operátorral (például ">") lép be egy utasításba, a PowerShell-hibakereső a parancsfájl összes többi utasítása fölé lép.

A parancsfájl-változók értékeinek megjelenítése

A hibakeresőben a parancsok megadására, a változók értékének megjelenítésére, a parancsmagok használatára, valamint a parancsfájlok futtatására is használható a parancssorban.

A parancsfájlban lévő összes változó aktuális értékét megjelenítheti a hibakeresőben, a következő automatikus változók kivételével:

$_
$Args
$Input
$MyInvocation
$PSBoundParameters

Ha bármelyik változó értékét megpróbálja megjeleníteni, akkor a változó értékét a hibakereső által használt belső adatcsatornán kapja meg, nem pedig a parancsfájlban szereplő változó értékét.

Ha meg szeretné adni a változók értékét a hibakereső parancsfájlhoz, a parancsfájlban rendeljen az automatikus változó értékét egy új változóhoz. Ezután megjelenítheti az új változó értékét.

Példa:

$scriptArgs = $Args
$scriptArgs

A jelen témakörben szereplő példában a változó értékét a $MyInvocation következőképpen rendeli hozzá a rendszer:

$scriptname = $MyInvocation.MyCommand.Path

A hibakereső környezete

Amikor eléri a töréspontot, a hibakereső környezetet kell megadnia. A parancssor úgy módosul, hogy "[DBG]:" kezdetű legyen. Ha egy munkafolyamatot hibakeresést végez, a következő üzenet jelenik meg: "[WFDBG]". Testreszabhatja a kérdést.

További információ a parancssor testreszabásáról: about_Prompts.

Emellett egyes gazdagép-alkalmazásokban, például a PowerShell-konzolon (de a Windows PowerShell integrált parancsfájlkezelési környezetében [ISE]) egy beágyazott prompt nyílik meg a hibakereséshez. A beágyazott promptot a parancssorban megjelenő, több mint karakteres (ASCII 62) karakterek használatával derítheti fel.

Például a következő a PowerShell-konzolon az alapértelmezett hibakeresési kérdés:

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

Az automatikus változó használatával megkeresheti a beágyazási szintet $NestedPromptLevel .

Emellett $PSDebugContext a helyi hatókörben is definiálva van egy automatikus változó. A változó jelenlétét használva $PsDebugContext megállapíthatja, hogy a hibakeresőben van-e.

Például:

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

Használhatja a változó értékét a $PSDebugContext hibakeresésben.

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

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

Hibakeresés és hatókör

A hibakeresőbe való betörés nem módosítja azt a hatókört, amelyben a működését végzi, de ha egy parancsfájlban elér egy töréspontot, a szkript hatókörbe kerül. A parancsfájl hatóköre annak a hatókörnek a gyermeke, amelyben futtatta a hibakeresőt.

A parancsfájl hatókörében definiált változók és aliasok megkereséséhez használja a (z) vagy a (z Get-Alias ) parancsmag hatókör-paraméterét Get-Variable .

Például a következő parancs lekéri a változókat a helyi (parancsfájl) hatókörben:

Get-Variable -scope 0

A parancs a következőképpen rövidíthető le:

gv -s 0

Ez egy hasznos módszer, ha csak a parancsfájlban definiált változókat látja, és a hibakeresés során definiálva van.

Hibakeresés a parancssorban

Ha változó töréspontot vagy egy parancs töréspontját állítja be, akkor a töréspontot csak egy parancsfájlban állíthatja be. Alapértelmezés szerint azonban a Töréspont minden olyan gépen be van állítva, amely az aktuális munkamenetben fut.

Ha például egy töréspontot állít be a $name változóhoz, a hibakereső minden olyan változót megszakít a $name parancsfájl, parancs, függvény, parancsfájl-parancsmag vagy kifejezés alapján, amelyet futtat, amíg le nem tiltja vagy el nem távolítja a töréspontot.

Ez lehetővé teszi a parancsfájlok hibakeresését egy reálisabb kontextusban, amelyben a függvények, változók és egyéb parancsfájlok befolyásolhatják a munkamenetben és a felhasználó profiljában.

A sorokhoz tartozó töréspontok kifejezetten a parancsfájl-fájlokra vonatkoznak, ezért csak parancsfájlokban vannak beállítva.

Munkafolyamatok hibakeresése

A PowerShell 4,0 hibakereső használható PowerShell-munkafolyamatok hibakereséséhez a PowerShell-konzolon vagy Windows PowerShell integrált parancsprogram-kezelési környezet. Bizonyos korlátozások vonatkoznak a PowerShell-hibakereső használatára a munkafolyamatok hibakereséséhez.

  • A hibakeresőben megtekintheti a munkafolyamat-változókat, de a hibakeresőn belüli munkafolyamat-változók beállítása nem támogatott.
  • A munkafolyamat-hibakereső leállításakor a TAB Befejezés nem érhető el.
  • A munkafolyamat-hibakeresés csak egy PowerShell-parancsfájlból származó munkafolyamatok szinkron futtatásával működik. A munkafolyamatok nem állíthatók be, ha feladatokként futnak (a AsJob paraméterrel).
  • Más beágyazott hibakeresési forgatókönyvek, például egy másik munkafolyamatot hívó munkafolyamatok vagy egy parancsfájlt hívó munkafolyamat nem valósulnak meg.

Az alábbi példa bemutatja a munkafolyamatok hibakeresését. Amikor a hibakereső bekerül a munkafolyamat-függvénybe, a hibakereső megkéri a következőt: "[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.

Hibakeresési függvények

Ha olyan függvényhez állít be töréspontot, amely Begin , Process és End szakaszokat tartalmaz, a hibakereső megszakítja az egyes szakaszok első sorát.

Például:

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>

Távoli parancsfájlok hibakeresése

A PowerShell 5,0-től kezdve a PowerShell-hibakeresőt futtathatja távoli munkamenetben, a konzolon vagy a Windows PowerShell integrált parancsprogram-kezelési környezet. Enter-PSSessiona funkció frissült, és megadhat egy távoli számítógépen futó leválasztott munkamenetet, amely jelenleg egy parancsfájlt futtat. Ha a futó parancsfájl töréspontot üt, az ügyfél-munkamenet automatikusan elindítja a hibakeresőt.

Az alábbi példa bemutatja, hogyan működik ez a funkció, és a 6., 11., 22. és 25. sorokban beállított töréspontokkal. Vegye figyelembe, hogy a példában a Debugger indításakor két azonosítási kérdés szerepel: annak a számítógépnek a neve, amelyen a munkamenet fut, valamint a DBG-kérő üzenet, amely lehetővé teszi, hogy hibakeresési módban legyen.

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éldák

Ez a tesztelési parancsfájl észleli az operációs rendszer verzióját, és megjeleníti a rendszer által megfelelő üzenetet. Tartalmaz egy függvényt, egy függvény hívását és egy változót.

A következő parancs a teszt parancsfájl tartalmát jeleníti meg:

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

Az indításhoz állítson be egy töréspontot a parancsfájlban egy érdekes helyen, például egy sort, egy parancsot, egy változót vagy egy függvényt.

Először hozzon létre egy sor töréspontot az aktuális könyvtárban található Test.ps1 szkript első sorában.

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

Ezt a parancsot a következő módon rövidítheti le:

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

A parancs egy sor-töréspont objektumot ad vissza (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

Most indítsa el a szkriptet.

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

Amikor a parancsfájl eléri az első töréspontot, a Töréspont üzenet azt jelzi, hogy a hibakereső aktív. Leírja a töréspontot, és előzetesen megtekinti a szkript első sorát, amely egy függvény deklarációja. A parancssor azt is megváltoztatja, hogy a hibakereső rendelkezik a vezérléssel.

Az előnézet sor tartalmazza a parancsfájl nevét és az előzetesen megtekintett parancs sorszámát.

Entering debug mode. Use h or ? for help.

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

test.ps1:1   function psversion {
# DBG>

A Step parancs (ok) használatával hajtsa végre az első utasítást a parancsfájlban, és megtekintheti a következő utasítást. A következő utasítás az $MyInvocation automatikus változó használatával állítja be a $scriptName változó értékét a parancsfájl elérési útjára és fájlnevére.

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

Ezen a ponton a $scriptName változó nem töltődik fel, de a változó értékét az értékének megjelenítésével ellenőrizheti. Ebben az esetben az érték a következő: $null .

DBG> $scriptname
# DBG>

Egy másik lépés parancs (ok) használatával hajtsa végre az aktuális utasítást, és tekintse meg a parancsfájl következő utasítását. A következő utasítás meghívja a PsVersion függvényt.

DBG> s
test.ps1:12  psversion

Ezen a ponton a $scriptName változó ki van töltve, de a változó értékét úgy ellenőrizheti, hogy megjeleníti az értékét. Ebben az esetben az érték a parancsfájl elérési útjára van állítva.

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

Egy másik lépés parancs használatával hajtsa végre a függvény hívását. Nyomja le az ENTER billentyűt, vagy írja be a "s" értéket a lépéshez.

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

A hibakeresési üzenet tartalmazza a függvény utasításának előnézetét. Az utasítás végrehajtásához és a függvény következő utasításának megtekintéséhez használhatja a Step parancsot. Ebben az esetben azonban használjon StepOut-parancsot (o). Befejezi a függvény végrehajtását (kivéve, ha eléri a töréspontot), és lépéseket tesz a parancsfájl következő utasítására.

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

Mivel a szkript utolsó utasítása van, a lépés, a StepOut és a folytatás parancs ugyanezt a hatást eredményezi. Ebben az esetben használja a StepOut (o).

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

A StepOut parancs végrehajtja az utolsó parancsot. A normál parancssor azt jelzi, hogy a hibakereső kilépett, és visszaadta a vezérlést a parancs processzorának.

Most futtassa újra a hibakeresőt. Először az aktuális töréspont törléséhez használja a és a Get-PsBreakpoint Remove-PsBreakpoint parancsmagot. (Ha úgy gondolja, hogy újra fel szeretné használni a töréspontot, használja a Disable-PsBreakpoint parancsmagot a helyett Remove-PsBreakpoint .)

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

Ezt a parancsot a következő módon rövidítheti le:

PS C:\ps-test> gbp | rbp

Vagy futtassa a parancsot egy függvény megírásával, például a következő függvénnyel:

function delbr { gbp | rbp }

Most hozzon létre egy töréspontot a $scriptname változóban.

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

A parancs a következőképpen rövidíthető le:

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

Most indítsa el a szkriptet. A szkript eléri a Töréspont változót. Az alapértelmezett mód az írás, ezért a végrehajtás csak a változó értékét módosító utasítás előtt leáll.

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>

A változó aktuális értékének megjelenítése $scriptName $null .

DBG> $scriptName
# DBG>

A változót feltöltő utasítás végrehajtásához használja a Step parancs (oka) t. Ezután jelenítse meg a változó új értékét $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

A következő utasítás a PsVersion függvény hívása. Ha ki szeretné hagyni a függvényt, de továbbra is végre kell hajtania, használjon egy StepOver-parancsot (v). Ha már szerepel a függvényben a StepOver használatakor, az nem érvényes. A függvény hívása megjelenik, de nem fut.

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

A StepOver parancs végrehajtja a függvényt, és előzetesen megjeleníti a parancsfájl következő utasítását, amely kiírja a végső sort.

A hibakeresőből való kilépéshez használjon leállítási parancsot (t). A parancssor visszavált a normál parancssorba.

C:\ps-test>

A töréspontok törléséhez használja a Get-PsBreakpoint és a Remove-PsBreakpoint parancsmagot.

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

Hozzon létre egy új parancs töréspontot a PsVersion függvényben.

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

Ezt a parancsot a következőre szűkítheti:

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

Most futtassa a parancsfájlt.

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

test.ps1:12  psversion
# DBG>

A szkript eléri a töréspontot a függvény hívásakor. Ezen a ponton a függvény még nem lett meghívva. Ez lehetőséget biztosít a művelet paraméterének használatára a Set-PSBreakpoint töréspont végrehajtásához, illetve az előkészítő vagy diagnosztikai feladatok végrehajtásához, például egy napló indításához vagy egy diagnosztikai vagy biztonsági parancsfájl meghívásához.

A művelet megadásához használja a Continue parancsot (c) a parancsfájlból való kilépéshez, valamint egy Remove-PsBreakpoint parancsot az aktuális töréspont törléséhez. (A töréspontok csak olvashatók, ezért nem adhat hozzá műveletet az aktuális törésponthoz.)

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>

Most hozzon létre egy új parancs-töréspontot egy művelettel. A következő parancs egy parancs töréspontját egy olyan művelettel állítja be, amely a $scriptName függvény hívásakor naplózza a változó értékét. Mivel a megszakítási kulcsszó nincs használatban a műveletben, a végrehajtás nem áll le. (A kezdő () a vonal-folytatási karakter.)

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

Hozzáadhat olyan műveleteket is, amelyek meghatározzák a Töréspont feltételeit. A következő parancsban a parancs töréspontját csak akkor hajtja végre a rendszer, ha a végrehajtási házirend a RemoteSigned értékre van állítva, a legszigorúbb házirend, amely továbbra is lehetővé teszi a parancsfájlok futtatását. (A kezdő () a folytatási karakter.)

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

A műveletben szereplő break kulcsszó irányítja a hibakeresőt a Töréspont végrehajtásához. A Continue (folytatás) kulcsszó használatával a hibakeresőt úgy is elvégezheti, hogy megszakítás nélkül végrehajtsa a végrehajtást. Mivel az alapértelmezett kulcsszó továbbra is fennáll, a végrehajtás leállításához meg kell adnia a break értéket.

Most futtassa a parancsfájlt.

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

test.ps1:12  psversion

Mivel a végrehajtási házirend RemoteSignedértékre van állítva, a végrehajtás leáll a függvény hívásakor.

Ezen a ponton érdemes lehet megtekinteni a hívási veremet. Használja a Get-PsCallStack parancsmagot vagy a Get-PsCallStack Debugger parancsot (k). A következő parancs lekéri az aktuális hívási veremet.

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

Ez a példa a PowerShell-hibakereső használatának számos módszerét mutatja be.

A Debugger parancsmagokkal kapcsolatos további információkért írja be a következő parancsot:

help <cmdlet-name> -full

Írja be például a következőt:

help Set-PSBreakpoint -full

Egyéb hibakeresési funkciók a PowerShellben

A PowerShell-hibakeresőn kívül a PowerShell számos más funkciót is tartalmaz, amelyeket a parancsfájlok és függvények hibakereséséhez használhat.

  • Windows PowerShell integrált parancsprogram-kezelési környezet tartalmaz egy interaktív grafikus hibakeresőt. További információért indítsa el Windows PowerShell integrált parancsprogram-kezelési környezet és nyomja meg az F1 billentyűt.

  • A Set-PSDebug parancsmag nagyon egyszerű parancsfájl-hibakeresési funkciókat kínál, beleértve a léptetést és a nyomkövetést.

  • A Set-StrictMode parancsmaggal azonosíthatja a nem inicializált változókat, az objektumok nem létező tulajdonságaira mutató hivatkozásokat, valamint a nem érvényes szintaxist.

  • Diagnosztikai utasítások hozzáadása egy parancsfájlhoz, például a változók értékét megjelenítő utasítások, a parancssorból beolvasott utasítások, illetve az aktuális útmutatást bejelentő utasítások. Használja a művelet írási műveletét tartalmazó parancsmagokat (például,,, Write-Host Write-Debug Write-Warning és Write-Verbose ).

LÁSD MÉG:

  • Last updated on