Ü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. Trap-Anweisungen behandeln die Beendigungsfehler und ermöglichen die Fortsetzung der Ausführung des Skripts oder der Funktion, anstatt sie zu stoppen.

Trap-Anweisungen können auch komplexer sein. Die Anweisungsliste des Traps kann mehrere Bedingungen oder Funktionsaufrufe enthalten. Ein Trap kann Protokolle schreiben, Bedingungen testen oder sogar ein anderes Programm ausführen.

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 trap Schlüsselwort, optional gefolgt von einem Typausdruck, und dem Anweisungsblock mit der Liste der Anweisungen, die ausgeführt werden sollen, wenn ein Fehler abgefangen wird. Der Typausdruck verfeinert die Arten von Fehlern, die vom Trap abgefangen werden.

Ein Skript oder Befehl kann mehrere Trap-Anweisungen enthalten. Trap-Anweisungen können an einer beliebigen Stelle im Skript oder Befehl angezeigt werden.

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, setzt 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 Beendigungsfehler 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.

Das folgende Beispiel enthält eine Trap-Anweisung, die den Fehler mithilfe der $_ Variablen automatic 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 then try
again.

Bestimmte Fehler abfangen

Ein Skript oder Befehl kann mehrere Trap-Anweisungen enthalten. Traps können 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 interceptped" an. Nach dem Ausführen der Trap-Anweisungsliste schreibt PowerShell das Fehlerobjekt in den Fehlerdatenstrom und setzt dann das Skript fort.

PowerShell verwendet die Microsoft .NET Framework-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 mehr als eine Trap-Anweisung in einem Skript haben. Jeder Fehlertyp kann nur von einer Trap-Anweisung abgefangen werden. Wenn ein Beendigungsfehler auftritt, sucht PowerShell nach dem Trap 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 jeden Beendigungsfehler 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 : 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.
At C:\temp\test\traptest.ps1:5 char:1
+ nonsenseString
+ ~~~~~~~~~~~~~~
+ CategoryInfo          : ObjectNotFound: (nonsenseString:String) [], CommandNotFoundException
+ FullyQualifiedErrorId : CommandNotFoundException

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
Attempted to divide by zero.
At C:\temp\test\traptest.ps1:5 char:1
+ 1/$null
+ ~~~~~~~
+ CategoryInfo          : NotSpecified: (:) [], RuntimeException
+ FullyQualifiedErrorId : RuntimeException

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 und Geltungsbereich

Wenn ein Beendigungsfehler im selben Bereich wie die Trap-Anweisung auftritt, führt PowerShell die Liste der Anweisungen aus, die durch das Trap 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 z. B. ein Fehler in einer Funktion auftritt und sich die Trap-Anweisung in der Funktion befindet, wird das Skript mit der nächsten Anweisung fortgesetzt. Das folgende Skript enthält eine error- und eine trap-Anweisung:

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

Später im Skript führt das Ausführen der Function1-Funktion zu folgendem Ergebnis:

function1
An error:
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
then try again.
At C:\PS>TestScript1.ps1:3 char:19
+     NonsenseString <<<<

function1 was completed

Die Trap-Anweisung in der Funktion fängt den Fehler ab. 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:
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
then try again.
At C:\PS>TestScript2.ps1:4 char:19
+     NonsenseString <<<<

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.

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 }

Verwenden der break Schlüsselwörter und continue

Sie können die Break Schlüsselwörter 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 aufnehmen, stoppt PowerShell die Funktion oder das Skript. In der folgenden Beispielfunktion wird das Break Schlüsselwort in einer Trap-Anweisung verwendet:

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

break_example

Error trapped
Attempted to divide by zero.
At line:4 char:7

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 eine Continue Anweisung in eine Trap-Anweisung einschließen, wird PowerShell nach der Anweisung, die den Fehler verursacht hat, fortgesetzt, genau wie ohne Break oder Continue. 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

about_Break

about_Continue

about_Scopes

about_Throw

über_Versuchen_Fangen_Finale