Share via

about_Trap

  • Artikel

Korte beschrijving

Beschrijft een trefwoord dat een afsluitfout afhandelt.

Lange beschrijving

Een afsluitfout voorkomt dat een instructie wordt uitgevoerd. 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 de afsluitfouten op de volgende manieren afhandelen:

  • Geef de fout weer na het verwerken van het trap instructieblok en continue uitvoering van het script of de functie met de trap. Dit gedrag is de standaardinstelling.

    Notitie

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

  • De fout weergeven en de uitvoering van het script of de functie met het trap gebruik break in de trap instructie afbreken.

  • De fout dempen, maar doorgaan met het uitvoeren van het script of de functie met behulp trap van continue de trap instructie.

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

Syntaxis

De trap instructie 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 met instructies die moeten worden uitgevoerd wanneer een fout wordt gevangen. De typeexpressie verfijnt de typen fouten die de trap vangsten veroorzaken.

Een script of opdracht kan meerdere trap instructies bevatten. trap instructies kunnen overal in het script of de opdracht worden weergegeven.

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 afhandelt. Als er een trap instructie aanwezig is, voert PowerShell het script of de opdracht in de trap instructie uit.

Het volgende voorbeeld is een minimale trap instructie:

trap { 'Error found.' }

Met deze trap instructie wordt elke afsluitfout onderschepd.

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 $_ 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.

Belangrijk

trap instructies kunnen overal binnen een bepaald scriptblok worden gedefinieerd, maar zijn altijd van toepassing op alle instructies in dat scriptblok. Tijdens runtime trap worden instructies in een blok gedefinieerd voordat andere instructies worden uitgevoerd. In JavaScript staat dit bekend als hijsen. Dit betekent dat trap instructies van toepassing zijn op alle instructies in dat blok, zelfs als de uitvoering nog niet is verstreken vanaf het punt waarop ze zijn gedefinieerd. Als u bijvoorbeeld een trap script aan het einde van een script definieert en een fout genereert in de eerste instructie, wordt dat trapnog steeds geactiveerd.

Specifieke fouten ondervangen

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

Het volgende voorbeeld is een trap instructie die de specifieke fout CommandNotFoundException trapt:

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. Na het uitvoeren van de trap instructielijst schrijft PowerShell het foutobject naar de foutstroom en gaat het script vervolgens verder.

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

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

Het fouttype CommandNotFoundException neemt het type System.Exception over. Deze instructie trapt eventuele fouten die worden gegenereerd door onbekende opdrachten. Er worden ook andere fouttypen onderschepd.

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 onderschept. 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 waarmee het type CommandNotFoundException wordt opgegeven.

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 niet herkent nonsenseString als een cmdlet of ander item, wordt er een CommandNotFoundException-fout geretourneerd. De specifieke trap instructie trapt deze afsluitfout.

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 een afsluitfout ondervangt, trapt de verdeling 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.

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

trap { 'An error occurred!'}
foreach ($x in 3..0) {
   1/$x
   'after division'
}
'after loop'

0.333333333333333
after division
0.5
after division
1
after division
An error occurred!
RuntimeException:
Line |
   3 |     1/$x
     |     ~~~~
     | Attempted to divide by zero.
after loop

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

Fouten en bereik insluiten

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. Uitvoering wordt voortgezet op de instructie 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 trap instructie 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 trapt de fout. Nadat het bericht is weergegeven, wordt de functie door PowerShell hervat. U ziet dat Function1 dit is voltooid na de trap instructie.

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

function function2 {
    NonsenseString
    'function2 was completed'
}

trap { 'An error:' }

function2

Als u de Function2 functie 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 function2 was completed opdracht niet uitgevoerd. In beide voorbeelden treedt de afsluitfout op binnen de functie. In dit voorbeeld bevindt de trap instructie zich echter buiten de functie. PowerShell gaat niet terug naar de functie nadat de trap instructie is uitgevoerd.

Let op

Wanneer er meerdere traps worden gedefinieerd voor dezelfde foutvoorwaarde, wordt de eerste trap gedefinieerde lexiek (hoogste in het scriptblok) gebruikt.

In het volgende voorbeeld worden alleen de trap uitvoeringen uitgevoerd whoops 1 .

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

Belangrijk

Een trap instructie is gericht op de locatie waar deze wordt gecompileerd. Als u een trap instructie in een functie- of puntbronscript hebt, worden alle trap instructies verwijderd wanneer de functie of het puntbronscript wordt afgesloten.

Het einde gebruiken en trefwoorden voortzetten

U kunt de break en continue trefwoorden in een trap instructie gebruiken om te bepalen of een script of opdracht blijft worden 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 break trefwoord bevat, blijft de functie niet actief en wordt de Function completed regel niet uitgevoerd.

Als u een continue trefwoord in een trap instructie opneemt, wordt PowerShell hervat na de instructie die de fout heeft veroorzaakt, net zoals 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 continue_example {
    trap {
        'Error trapped'
        continue
    }
    1/$null
    'Function completed.'
}

continue_example

Error trapped
Function completed.

De functie wordt hervat nadat de fout is vastgelopen en de Function completed 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 blokken waarin traps worden gedefinieerd met behulp van instructies voor nauwkeurigere foutafhandelingtrycatch/.catch De catch instructies zijn alleen van toepassing op de code in de bijbehorende try instructie. Zie about_Try_Catch_Finally voor meer informatie.

Zie ook