about_Trap

  • Artikel
  • 9 minuten om te lezen

Korte beschrijving

Beschrijft een trefwoord dat een afsluitfout verwerkt.

Lange beschrijving

Een afsluitfout voorkomt dat een instructie wordt uitgevoerd. Als PowerShell op een bepaalde manier geen afsluitfout verwerkt, 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 verwerken:

  • Geef de fout weer na het verwerken van het trap instructieblok en continue uitvoering van het script of de functie met de trap. Dit 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 die het trap gebruik break in de trap instructie bevat, afbreken.

  • De fout dempen, maar doorgaan met het uitvoeren van het script of de functie die de trap instructie continuetrap bevat.

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.

Syntax

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 typeexpressie 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 hebben. trap instructies kunnen overal in het script of de opdracht worden weergegeven.

Alle afsluitfouten insluiten

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, gaat PowerShell door met het uitvoeren van het script of de opdracht in de trap instructie.

Het volgende voorbeeld is een zeer eenvoudige trap instructie:

trap {"Error found."}

Deze trap instructie trapt elke afsluitfout.

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 het volgende geretourneerd:

Error found.
nonsenseString:
Line |
   3 |      nonsenseString
     |      ~~~~~~~~~~~~~~
     | 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.

In het volgende voorbeeld ziet u een trap instructie waarin 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 het volgende 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 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.

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 op het punt waarop ze zijn gedefinieerd. Als u bijvoorbeeld een trap aan het einde van een script definieert en een fout genereert in de eerste instructie, wordt dat trapnog steeds geactiveerd.

Specifieke fouten insluiten

Een script of opdracht kan meerdere trap instructies hebben. Een trap kan worden gedefinieerd voor het afhandelen van specifieke fouten.

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, wordt in deze trap instructie de tekenreeks 'Opdrachtfout gevangen' weergegeven. 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 over van het type System.Exception . Met deze instructie wordt een fout getrapt die is gemaakt door een onbekende opdracht. Er worden ook andere fouttypen overvallen.

U kunt meer dan één trap instructie in een script hebben. Elk fouttype kan slechts één trap instructie bevatten. 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 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.

Omdat 'nonsenseString' niet wordt herkend als een cmdlet of een ander item, retourneert PowerShell een CommandNotFoundException-fout . Deze afsluitfout wordt gevangen door de specifieke trap instructie.

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 |
   4 |  1/$null
     |  ~~~~~~~
     | Attempted to divide by zero.

De poging om door nul te delen, maakt geen CommandNotFoundException-fout . In plaats daarvan wordt die fout gevangen door de andere trap instructie, waardoor een afsluitfout wordt overvallen.

Fouten in een scriptblok insluiten

Wanneer er een afsluitfout wordt gegenereerd, 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: untitled:Untitled-1:3:4
Line |
   3 |     1/$x
     |     ~~~~
     | Attempted to divide by zero.

after loop

In de bovenstaande uitvoer ziet u dat de lussen doorgaan tot de laatste iteratie. Wanneer het script probeert 1 door 0 te delen, wordt er een afsluitfout gegenereerd. De rest van het foreach scriptblok wordt overgeslagen, de try instructie wordt uitgevoerd en het script wordt voortgezet na de foreach scriptblokkering.

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. De uitvoering wordt voortgezet op de instructie na de fout. Als de trap instructie zich in een ander scriptblok bevindt dan de fout, wordt de uitvoering voortgezet op 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 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.
function1 was completed

De trap instructie in de functie trapt de fout. Nadat het bericht is weergegeven, wordt de functie opnieuw uitgevoerd in PowerShell. Houd er rekening mee dat dit Function1 is voltooid.

Vergelijk dit 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 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.

In dit voorbeeld is de opdracht 'function2 was completed' niet uitgevoerd. In beide voorbeelden treedt de afsluitfout op in 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.

Waarschuwing

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

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 }

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 binnen een functie of puntbronscript verwijderd wanneer het functie- of puntbronscript wordt afgesloten.

Trefwoorden onderbreken en doorgaan gebruiken

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

Als u een break instructie in een trap instructielijst opneemt, 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 regel 'Functie voltooid' 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 gevangen en de instructie 'Functie voltooid' wordt uitgevoerd. Er wordt geen fout naar de foutstroom geschreven.

Notities

trap instructies bieden een manier om ervoor te zorgen dat alle afsluitfouten in een scriptblok worden verwerkt. Gebruik voor nauwkeurigere 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_Finally voor meer informatie.

Zie ook