about_Trap

Korte beschrijving

Beschrijft een trefwoord dat een afsluitfout afhandelt.

Lange beschrijving

Een fout die beëindigend is, houdt een instructie tegen om uitgevoerd te worden. Als PowerShell op een of andere manier geen afsluitfout afhandelt, stopt PowerShell ook met het uitvoeren van de functie of het script in de huidige pijplijn. In andere talen, zoals C#, worden afsluitfouten ook wel uitzonderingen genoemd.

Het trap trefwoord geeft een lijst met instructies op die moeten worden uitgevoerd wanneer er een afsluitfout optreedt. trap-instructies kunnen terminale fouten op de volgende manieren afhandelen:

• Geef de fout weer nadat het instructieblok trap verwerkt geworden is en de uitvoering van het script of de functie die trapbevat wordt voortgezet. Dit gedrag is de standaardinstelling.

  Notitie

  Wanneer de afsluitfout optreedt in een onderliggende instructieblok, zoals een if instructie of foreach lus, worden de instructies in het trap blok uitgevoerd en wordt de uitvoering voortgezet bij de volgende instructie buiten het onderliggende blok.

• Geef de fout weer en stop de uitvoering van het script of de functie die trap bevat met behulp van break in de trap-instructie.

• Stilleer de fout, maar ga door met het uitvoeren van het script of de functie die trap bevat door continue te gebruiken in de verklaring trap.

De instructielijst van de trap kan meerdere voorwaarden of functie-aanroepen bevatten. Een trap kan logboeken, testvoorwaarden schrijven of zelfs een ander programma uitvoeren.

Syntaxis

De instructie trap heeft de volgende syntaxis:

trap [[<error type>]] {<statement list>}

De trap-instructie bevat een lijst met instructies die moeten worden uitgevoerd wanneer er een afsluitfout optreedt. Een trap-instructie bestaat uit het trap-trefwoord, eventueel gevolgd door een type-expressie, en het instructieblok met de lijst van instructies die moeten worden uitgevoerd wanneer een fout optreedt. De typeexpressie verfijnt de typen fouten die de trap ondervangst.

Een script of opdracht kan meerdere trap instructies hebben. trap-verklaringen kunnen overal in het script of de opdracht voorkomen.

Alle afsluitfouten ondervangen

Wanneer er een afsluitfout optreedt die niet op een andere manier wordt verwerkt in een script of opdracht, controleert PowerShell op een trap instructie die de fout verwerkt. Als er een trap-instructie aanwezig is, wordt het script of de opdracht in de trap-instructie door PowerShell uitgevoerd.

Het volgende voorbeeld is een minimale trap-instructie:

trap { 'Error found.' }

Deze trap instructie vangt elke terminërende fout op.

In het volgende voorbeeld bevat de functie een onzintekenreeks die een runtimefout veroorzaakt.

function TrapTest {
    trap { 'Error found.' }
    nonsenseString
}

TrapTest

Als u deze functie uitvoert, wordt de volgende uitvoer geretourneerd:

Error found.
nonsenseString:
Line |
   3 |      nonsenseString
     |      ~~~~~~~~~~~~~~
     | The term 'nonsenseString' is not recognized as a name of a cmdlet,
function, script file, or executable program.
Check the spelling of the name, or if a path was included, verify that the
path is correct and try again.

Het volgende voorbeeld bevat een trap instructie waarmee de fout wordt weergegeven met behulp van de $_ of $PSItem automatische variabele:

function TrapTest {
    trap { "Error found: $_" }
    nonsenseString
}

TrapTest

Als u deze versie van de functie uitvoert, wordt de volgende uitvoer geretourneerd:

Error found: The term 'nonsenseString' is not recognized as the name of a
cmdlet, function, script file, or operable program. Check the spelling of
the name, or if a path was included, verify that the path is correct and
try again.
nonsenseString:
Line |
   3 |      nonsenseString
     |      ~~~~~~~~~~~~~~
     | The term 'nonsenseString' is not recognized as a name of a cmdlet,
function, script file, or executable program.
Check the spelling of the name, or if a path was included, verify that the
path is correct and try again.

Specifieke fouten ondervangen

Een script of opdracht kan meerdere trap instructies hebben. Een trap kan worden gedefinieerd om specifieke fouten af te handelen.

Het volgende voorbeeld is een trap werkwijze die de specifieke fout CommandNotFoundExceptionopvangt:

trap [System.Management.Automation.CommandNotFoundException] {
    'Command error trapped'
}

Wanneer een functie of script een tekenreeks tegenkomt die niet overeenkomt met een bekende opdracht, geeft deze trap instructie de Command error trapped tekenreeks weer. Nadat de trap-instructielijst is uitgevoerd, schrijft PowerShell het foutobject naar de foutstroom en gaat het script door.

PowerShell maakt gebruik van .NET-uitzonderingstypen. In het volgende voorbeeld wordt het System.Exception fouttype opgegeven:

trap [System.Exception] { 'An error trapped' }

De CommandNotFoundException fouttype wordt overgenomen van het System.Exception type. Deze verklaring onderschept eventuele fouten die worden opgeworpen door onbekende opdrachten. Er worden ook andere fouttypen onderschept.

U kunt het uitzonderingstype voor een fout vinden door het foutobject te controleren. In het volgende voorbeeld ziet u hoe u de volledige naam van de uitzondering voor de laatste fout in een sessie kunt ophalen:

nonsenseString
$Error[0].Exception.GetType().FullName

nonsenseString: The term 'nonsenseString' is not recognized as a name of a
cmdlet, function, script file, or executable program. Check the spelling
of the name, or if a path was included, verify that the path is correct
and try again.

System.Management.Automation.CommandNotFoundException

U kunt meer dan één trap instructie in een script hebben. Slechts één trap instructie kan elk fouttype ondervangen. Wanneer er een afsluitfout optreedt, zoekt PowerShell naar de trap meest specifieke overeenkomst, te beginnen in het huidige scriptblok van de uitvoering.

Het volgende scriptvoorbeeld bevat een fout. Het script bevat een algemene trap-instructie waarmee een afsluitfout wordt onderschept en een specifieke trap-instructie die het type CommandNotFoundException aangeeft.

trap { 'Other terminating error trapped' }
trap [System.Management.Automation.CommandNotFoundException] {
  'Command error trapped'
}
nonsenseString

Als u dit script uitvoert, wordt het volgende resultaat gegenereerd:

Command error trapped
nonsenseString:
Line |
   5 |      nonsenseString
     |      ~~~~~~~~~~~~~~
     | The term 'nonsenseString' is not recognized as a name of a cmdlet,
function, script file, or executable program.
Check the spelling of the name, or if a path was included, verify that the
path is correct and try again.

Omdat PowerShell nonsenseString niet herkent als een cmdlet of ander item, wordt er een CommandNotFoundException-fout geretourneerd. De specifieke trap instructie vangt deze fatale fout op.

Het volgende scriptvoorbeeld bevat dezelfde trap instructies met een andere fout:

trap { 'Other terminating error trapped' }
trap [System.Management.Automation.CommandNotFoundException] {
    'Command error trapped'
}
1/$null

Als u dit script uitvoert, wordt het volgende resultaat gegenereerd:

Other terminating error trapped
RuntimeException:
Line |
   5 |  1/$null
     |  ~~~~~~~
     | Attempted to divide by zero.

De poging om te delen door nul maakt geen CommandNotFoundException fout. De andere trap-instructie, die elke beëindigingsfout ondervangt, ondervangt ook de fout van delen door nul.

Fouten in een scriptblok ondervangen

Wanneer er een afsluitfout optreedt, wordt de uitvoering standaard overgedragen naar de trapinstructie. Nadat het trap blok is uitgevoerd, keert het besturingselement terug naar het volgende instructieblok na de locatie van de fout.

Wanneer er bijvoorbeeld een afsluitfout optreedt in een foreach instructie, wordt de trap instructie uitgevoerd en wordt de uitvoering voortgezet op de volgende instructie na het foreach blok, niet binnen het foreach blok.

trap { 'An error occurred!'}
foreach ($x in 3..-1) {
       "1/$x = "
       "`t$(1/$x)"
}
'after loop'

1/3 =
        0.333333333333333
1/2 =
        0.5
1/1 =
        1
1/0 =
An error occurred!
RuntimeException:
Line |
   4 |         "`t$(1/$x)"
     |              ~~~~
     | Attempted to divide by zero.
after loop

In de uitvoer ziet u dat de herhalingen doorgaan tot de laatste iteratie. Wanneer het script probeert 1 door 0 te delen, genereert PowerShell een afsluitfout. Het script slaat de rest van de foreach instructie over, voert de try instructie uit en gaat verder na de foreach instructie.

Fouten opvangen en context definiëren

Als er een afsluitfout optreedt in hetzelfde scriptblok als de trap instructie, voert PowerShell de lijst met instructies uit die zijn gedefinieerd door de trap. De uitvoering gaat verder bij de opdracht na de fout. Als de trap instructie zich in een ander scriptblok bevindt dan de fout, gaat de uitvoering verder met de volgende instructie die zich in hetzelfde scriptblok bevindt als de trap instructie.

Als er bijvoorbeeld een fout optreedt in een functie en de instructie trap zich in de functie bevindt, gaat het script verder met de volgende instructie. Het volgende script bevat een fout en een trap instructie:

function function1 {
    trap { 'An error: ' }
    NonsenseString
    'function1 was completed'
}

function1

Als u dit script uitvoert, wordt het volgende resultaat gegenereerd:

An error:
NonsenseString:
Line |
   3 |      NonsenseString
     |      ~~~~~~~~~~~~~~
     | The term 'NonsenseString' is not recognized as a name of a cmdlet,
function, script file, or executable program.
Check the spelling of the name, or if a path was included, verify that the
path is correct and try again.
function1 was completed

De trap instructie in de functie vangt de fout op. Nadat het bericht is weergegeven, wordt de functie door PowerShell hervat. Merk op dat Function1 is voltooid na de trap-verklaring.

Vergelijk dit gedrag met het volgende voorbeeld, dat dezelfde fout en trap-statement bevat. In dit voorbeeld vindt de trap-instructie plaats buiten de functie:

function function2 {
    NonsenseString
    'function2 was completed'
}

trap { 'An error:' }

function2

Als u de functie Function2 uitvoert, wordt het volgende resultaat gegenereerd:

An error:
NonsenseString:
Line |
   2 |      NonsenseString
     |      ~~~~~~~~~~~~~~
     | The term 'NonsenseString' is not recognized as a name of a cmdlet,
function, script file, or executable program.
Check the spelling of the name, or if a path was included, verify that the
path is correct and try again.

In dit voorbeeld is de opdracht function2 was completed niet uitgevoerd. In beide voorbeelden treedt de afsluitfout op binnen de functie. In dit voorbeeld bevindt de instructie trap zich echter buiten de functie. PowerShell gaat niet terug naar de functie nadat de trap instructie is uitgevoerd.

In het volgende voorbeeld wordt alleen de trap met whoops 1 uitgevoerd.

Remove-Item -ErrorAction Stop ThisFileDoesNotExist
trap { 'whoops 1'; continue }
trap { 'whoops 2'; continue }

Het gebruik van de keywords break en continue

U kunt de break en continue trefwoorden in een trap instructie gebruiken om te bepalen of een script of opdracht wordt uitgevoerd na een afsluitfout.

Als u een break instructie opneemt in een trap instructielijst, stopt PowerShell de functie of het script. De volgende voorbeeldfunctie gebruikt het break trefwoord in een trap-instructie:

function break_example {
    trap {
        'Error trapped'
        break
    }
    1/$null
    'Function completed.'
}

break_example

Error trapped
ParentContainsErrorRecordException:
Line |
   6 |      1/$null
     |      ~~~~~~~
     | Attempted to divide by zero.

Omdat de trap instructie het trefwoord break bevat, blijft de functie niet actief en wordt de Function completed regel niet uitgevoerd.

Als u een continue-trefwoord opneemt in een trap-instructie, gaat PowerShell verder na de instructie die de fout heeft veroorzaakt, net als zonder break of continue. Met het continue trefwoord schrijft PowerShell echter geen fout naar de foutstroom.

De volgende voorbeeldfunctie gebruikt het continue trefwoord in een trap-instructie:

function ContinueExample {
    trap {
        'Error trapped'
        continue
    }
    foreach ($x in 3..-1) {
       "1/$x = "
       "`t$(1/$x)"
    }
    'End of function'
}

ContinueExample

1/3 =
        0.333333333333333
1/2 =
        0.5
1/1 =
        1
1/0 =
Error trapped
End of function

De functie wordt hervat nadat de fout is vastgelopen en de End of function instructie wordt uitgevoerd. Er wordt geen fout naar de foutstroom geschreven.

Opmerkingen

trap instructies bieden een manier om ervoor te zorgen dat alle afsluitfouten in een scriptblok worden verwerkt. Gebruik voor gedetailleerdere foutafhandeling try/catch blokken waarbij traps worden gedefinieerd met behulp van catch instructies. De catch-instructies zijn alleen van toepassing op de code in de bijbehorende try-instructie. Zie about_Try_Catch_Finallyvoor meer informatie.

Zie ook

• about_Break
• about_Continue
• about_Scopes
• about_Throw
• about_Try_Catch_Finally