Freigeben über

Über_Trap

Kurzbeschreibung

Beschreibt ein Schlüsselwort, das einen Beendigungsfehler verarbeitet.

Lange Beschreibung

Ein Fehler mit Abbruch stoppt die Ausführung einer Anweisung. Wenn PowerShell einen Beendigungsfehler nicht in irgendeiner Weise behandelt, beendet PowerShell auch die Ausführung der Funktion oder des Skripts in der aktuellen Pipeline. In anderen Sprachen, z. B. C#, werden Abbruchfehler als Ausnahmen bezeichnet.

Das schlüsselwort trap gibt eine Liste der auszuführenden Anweisungen an, wenn ein Beendigungsfehler auftritt. Mit trap-Anweisungen können die Fehler mit Abbruch folgendermaßen behandelt werden:

  • Anzeigen des Fehlers nach der Verarbeitung des trap-Anweisungsblocks und Fortsetzen der Ausführung des Skripts oder der Funktion, das/die den trap enthält. Dies ist das Standardverhalten.

    Hinweis

    Wenn der Beendigungsfehler in einem untergeordneten Skriptblock auftritt, z. B. in einer if-Anweisung oder foreach Schleife, werden die Anweisungen im trap-Block ausgeführt, und die Ausführung wird bei der nächsten Anweisung außerhalb des untergeordneten Skriptblocks fortgesetzt.

  • Zeigen Sie den Fehler an und brechen Sie die Ausführung des Skripts oder der Funktion mit dem trap mithilfe von break in der trap-Anweisung an.

  • Stillen Sie den Fehler, setzen Sie jedoch die Ausführung des Skripts oder der Funktion fort, das die trap enthält, indem Sie continue in der trap-Anweisung verwenden.

Die Anweisungsliste der trap kann mehrere Bedingungen oder Funktionsaufrufe enthalten. Ein trap kann Protokolle, Testbedingungen oder sogar ein anderes Programm schreiben.

Syntax

Die trap-Anweisung weist die folgende Syntax auf:

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

Die trap-Anweisung enthält eine Liste von Anweisungen, die ausgeführt werden sollen, wenn ein Beendigungsfehler auftritt. Eine trap-Anweisung besteht aus dem schlüsselwort trap, optional gefolgt von einem Typausdruck und dem Anweisungsblock, der die Liste der auszuführenden Anweisungen enthält, wenn ein Fehler abgefangen wird. Der Typausdruck optimiert die Fehlertypen, die vom trap abgefangen werden.

Ein Skript oder Ein Befehl kann mehrere trap-Anweisungen aufweisen. trap-Anweisungen können überall im Skript oder Befehl vorkommen.

Abfangen aller Fehler mit Abbruch

Wenn ein Beendigungsfehler auftritt, der nicht auf andere Weise in einem Skript oder Befehl behandelt wird, sucht PowerShell nach einer trap Anweisung, die den Fehler behandelt. Wenn eine trap-Anweisung vorhanden ist, führt PowerShell die Ausführung des Skripts oder Befehls in der trap-Anweisung fort.

Das folgende Beispiel ist eine sehr einfache trap Anweisung:

trap {"Error found."}

Diese trap-Anweisung fängt alle Fehler mit Abbruch ab.

Im folgenden Beispiel enthält die Funktion eine Unsinnszeichenfolge, die einen Laufzeitfehler verursacht.

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

TrapTest

Das Ausführen dieser Funktion gibt Folgendes zurück:

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.

Das folgende Beispiel enthält eine trap-Anweisung, die den Fehler mithilfe der $_ automatischen Variablen anzeigt:

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

TrapTest

Wenn Sie diese Version der Funktion ausführen, wird Folgendes zurückgegeben:

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.

Von Bedeutung

trap Anweisungen können an einer beliebigen Stelle innerhalb eines bestimmten Gültigkeitsbereichs definiert werden, gelten aber immer für alle Anweisungen in diesem Bereich. Zur Laufzeit werden trap-Anweisungen in einem Block definiert, bevor andere Anweisungen ausgeführt werden. In JavaScript wird dieser Vorgang als Hoisting bezeichnet. Das bedeutet, dass Anweisungen auf alle Anweisungen in diesem Block angewendet werden, trap auch wenn die Ausführung nicht über den Punkt hinaus fortgeschritten ist, an dem sie definiert sind. Wird ein trap beispielsweise am Ende eines Skripts definiert und ein Fehler in der ersten Anweisung ausgelöst, so wird dieser trap weiterhin ausgelöst.

Bestimmte Fehler abfangen

Ein Skript oder Ein Befehl kann mehrere trap-Anweisungen aufweisen. Ein trap kann definiert werden, um bestimmte Fehler zu behandeln.

Das folgende Beispiel ist eine trap-Anweisung, die den spezifischen Fehler CommandNotFoundException abfängt:

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

Wenn eine Funktion oder ein Skript auf eine Zeichenfolge trifft, die nicht mit einem bekannten Befehl übereinstimmt, zeigt diese trap Anweisung die Zeichenfolge "Command error trapped" an. Nach dem Ausführen der trap-Anweisungsliste schreibt PowerShell das Fehlerobjekt in den Fehlerdatenstrom und setzt dann das Skript fort.

PowerShell verwendet .NET-Ausnahmetypen. Im folgenden Beispiel wird der System.Exception Fehlertyp angegeben:

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

Der Fehlertyp CommandNotFoundException erbt vom Typ System.Exception. Diese Anweisung fängt einen Fehler ab, der durch einen unbekannten Befehl erstellt wurde. Sie fängt auch andere Fehlertypen ab.

Sie können für ein Skript mehrere trap-Anweisungen festlegen. Jeder Fehlertyp kann nur durch eine trap Anweisung abgefangen werden. Wenn ein Beendigungsfehler auftritt, sucht PowerShell nach dem trap Fehler mit der spezifischsten Übereinstimmung, beginnend im aktuellen Ausführungsbereich.

Das folgende Skriptbeispiel enthält einen Fehler. Das Skript enthält eine allgemeine trap-Anweisung, die einen terminierenden Fehler abfängt, und eine spezifische trap-Anweisung, die den CommandNotFoundException Typ angibt.

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

Wenn Sie dieses Skript ausführen, wird das folgende Ergebnis erzeugt:

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.

Da PowerShell "nonsenseString" nicht als Cmdlet oder anderes Element erkennt, wird der CommandNotFoundException-Fehler zurückgegeben. Dieser Beendigungsfehler wird durch die spezifische trap Anweisung abgefangen.

Das folgende Skriptbeispiel enthält die gleichen trap Anweisungen mit einem anderen Fehler:

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

Wenn Sie dieses Skript ausführen, wird das folgende Ergebnis erzeugt:

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

Der Versuch, durch Null zu dividieren, führt nicht zu einem CommandNotFoundException-Fehler . Stattdessen wird dieser Fehler von der anderen trap Anweisung abgefangen, die jeden Beendigungsfehler abfängt.

Abfangen von Fehlern in einem Skriptblock

Wenn ein Fehler mit Abbruch auftritt, wird die Ausführung standardmäßig an die Trap-Anweisung übergeben. Nachdem der trap-Block ausgeführt wurde, kehrt das Steuerelement nach der Position des Fehlers zum nächsten Anweisungsblock zurück.

Wenn beispielsweise ein Beendigungsfehler in einer foreach-Anweisung auftritt, wird die trap-Anweisung ausgeführt, und die Ausführung wird bei der nächsten Anweisung nach dem foreach-Block fortgesetzt, nicht innerhalb des foreach-Blocks.

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 der obigen Ausgabe können Sie sehen, dass die Schleifen bis zur letzten Iteration fortgesetzt werden. Wenn das Skript versucht, 1 durch 0 zu dividieren, wird ein Beendigungsfehler ausgelöst. Der Rest des foreach Skriptblocks wird übersprungen, die try Anweisung wird ausgeführt, und das Skript wird nach dem foreach Skriptblock fortgesetzt.

Abfangen von Fehlern und Geltungsbereich

Wenn ein Beendigungsfehler im selben Bereich wie die trap Anweisung auftritt, führt PowerShell die Liste der Anweisungen aus, die trapdurch definiert sind. Die Ausführung wird nach der Anweisung fortgesetzt, die auf den Fehler folgt. Wenn sich die trap Anweisung in einem anderen Bereich als der Fehler befindet, wird die Ausführung bei der nächsten Anweisung fortgesetzt, die sich im selben Bereich wie die trap Anweisung befindet.

Wenn beispielsweise ein Fehler in einer Funktion auftritt und sich die trap-Anweisung in der Funktion befindet, wird das Skript an der nächsten Anweisung fortgesetzt. Das folgende Skript enthält einen Fehler und eine trap-Anweisung:

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

function1

Wenn Sie dieses Skript ausführen, wird das folgende Ergebnis erzeugt:

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

Die trap-Anweisung in der Funktion fängt den Fehler auf. Nach dem Anzeigen der Nachricht setzt PowerShell die Ausführung der Funktion fort. Beachten Sie, dass dies Function1 abgeschlossen wurde.

Vergleichen Sie dies mit dem folgenden Beispiel, das den gleichen Fehler und trap die gleiche Anweisung aufweist. In diesem Beispiel tritt die trap-Anweisung außerhalb der Funktion auf:

function function2 {
    NonsenseString
    "function2 was completed"
}

trap { "An error: " }

function2

Wenn Sie die Function2-Funktion ausführen, wird das folgende Ergebnis erzeugt:

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 diesem Beispiel wurde der Befehl "function2 was completed" nicht ausgeführt. In beiden Beispielen tritt der Beendigungsfehler innerhalb der Funktion auf. In diesem Beispiel befindet sich die trap-Anweisung jedoch außerhalb der Funktion. PowerShell kehrt nach dem Ausführen der trap Anweisung nicht in die Funktion zurück.

Vorsicht

Wenn mehrere Traps für dieselbe Fehlerbedingung definiert sind, wird die erste trap lexikalisch definierte (höchste im Bereich) verwendet.

Im folgenden Beispiel wird nur der trap mit "whoops 1" ausgeführt.

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

Von Bedeutung

Eine Trap-Anweisung ist auf den Ort beschränkt, an dem sie kompiliert wird. Wenn Sie eine trap-Anweisung innerhalb einer Funktion oder eines Dot-Source-Skripts haben, werden, wenn die Funktion oder das Dot-Source-Skript beendet wird, alle trap-Anweisungen darin entfernt.

Verwenden der Schlüsselwörter „break“ und „continue“

Sie können die schlüsselwörter break und continue in einer trap-Anweisung verwenden, um zu bestimmen, ob ein Skript oder Befehl nach einem Beendigungsfehler weiterhin ausgeführt wird.

Wenn Sie eine break-Anweisung in eine trap-Anweisungsliste einschließen, stoppt PowerShell die Funktion oder das Skript. Die folgende Beispielfunktion verwendet das schlüsselwort break in einer trap-Anweisung:

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.

Da die trap Anweisung das break Schlüsselwort enthält, wird die Funktion nicht weiter ausgeführt, und die Zeile "Funktion abgeschlossen" wird nicht ausgeführt.

Wenn Sie ein continue-Schlüsselwort in eine trap-Anweisung einfügen, setzt PowerShell nach der Anweisung, die den Fehler verursacht hat, die Ausführung fort, genauso, als ob es ohne break oder continuewäre. Mit dem continue Schlüsselwort schreibt PowerShell jedoch keinen Fehler in den Fehlerstrom.

Die folgende Beispielfunktion verwendet das schlüsselwort continue in einer trap-Anweisung:

function continue_example {
    trap {
        "Error trapped"
        continue
    }
    1/$null
    "Function completed."
}

continue_example

Error trapped
Function completed.

Die Funktion wird fortgesetzt, nachdem der Fehler abgefangen wurde, und die Anweisung "Funktion abgeschlossen" wird ausgeführt. Es wird kein Fehler in den Fehlerdatenstrom geschrieben.

Hinweise

trap Anweisungen bieten eine einfache Möglichkeit, um allgemein sicherzustellen, dass alle Beendigungsfehler innerhalb eines Bereichs behandelt werden. Verwenden Sie für eine genauere Fehlerbehandlung try/catch Blöcke, bei denen Traps mithilfe von catch-Anweisungen definiert werden. Die catch-Anweisungen gelten nur für den Code innerhalb der zugeordneten try-Anweisung. Weitere Informationen finden Sie unter über_Versuchen_Fangen_Finale.

Siehe auch

  • Last updated on