Freigeben über

Informationen zu Trap

  • Artikel

Kurze Beschreibung

Beschreibt eine Schlüsselwort (keyword), die einen Abbruchfehler behandelt.

Lange Beschreibung

Ein Abbruchfehler beendet die Ausführung einer Anweisung. Wenn PowerShell einen Abbruchfehler in irgendeiner Weise nicht 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.

Die trap Schlüsselwort (keyword) gibt eine Liste von Anweisungen an, die ausgeführt werden sollen, wenn ein Abbruchfehler auftritt. trap -Anweisungen behandeln die Beendigungsfehler wie folgt:

  • Zeigt den Fehler nach der Verarbeitung des trap Anweisungsblocks und der fortgesetzten Ausführung des Skripts oder der Funktion an, das den trapenthält. Dies ist das Standardverhalten.

  • Zeigen Sie den Fehler an, und brechen Sie die Ausführung des Skripts oder der Funktion ab, das den trap in break der trap -Anweisung enthält.

  • Beenden Sie den Fehler, aber setzen Sie die Ausführung des Skripts oder der Funktion mit in trapcontinue der trap -Anweisung fort.

Die Anweisungsliste des trap 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 Abbruchfehler auftritt. Eine trap -Anweisung besteht aus dem trap Schlüsselwort (keyword), optional gefolgt von einem Typausdruck, und dem Anweisungsblock, der die Liste der Anweisungen enthält, die ausgeführt werden sollen, wenn ein Fehler abgefangen wird. Der Typausdruck verfeinert die Typen von Fehlern, die die trap abfangen.

Ein Skript oder ein Befehl kann über mehrere trap Anweisungen verfügen. trap -Anweisungen können an einer beliebigen Stelle im Skript oder Befehl angezeigt werden.

Abfangen aller Abbruchfehler

Wenn ein Abbruchfehler auftritt, der in einem Skript oder Befehl nicht anders behandelt wird, sucht PowerShell nach einer trap Anweisung, die den Fehler behandelt. Wenn eine trap -Anweisung vorhanden ist, führt PowerShell das Skript oder den Befehl in der trap -Anweisung weiter aus.

Das folgende Beispiel ist eine sehr einfache trap Anweisung:

trap {"Error found."}

Diese trap Anweisung fängt jeden Abbruchfehler ab.

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

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

TrapTest

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

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.

Wichtig

trap -Anweisungen können an einer beliebigen Stelle innerhalb eines bestimmten Bereichs definiert werden, gelten aber immer für alle Anweisungen in diesem Bereich. Zur Laufzeit werden Anweisungen in einem Block definiert, trap bevor andere Anweisungen ausgeführt werden. In JavaScript wird dies als "Huben" bezeichnet. Dies bedeutet, dass trap Anweisungen auf alle Anweisungen in diesem Block angewendet werden, auch wenn die Ausführung nicht über den Punkt hinaus fortgeschritten ist, an dem sie definiert sind. Wenn Sie z. B. ein trap am Ende eines Skripts definieren und einen Fehler in der ersten Anweisung auslösen, wird weiterhin ausgelöst.trap

Abfangen bestimmter Fehler

Ein Skript oder ein Befehl kann über mehrere trap Anweisungen verfügen. Ein trap kann definiert werden, um bestimmte Fehler zu behandeln.

Das folgende Beispiel ist eine trap Anweisung, die den spezifischen Fehler CommandNotFoundException abfangen:

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 Fehlerstream und setzt dann das Skript fort.

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

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

Der Fehlertyp CommandNotFoundException erbt vom System.Exception-Typ . Diese Anweisung fängt einen Fehler ab, der von einem unbekannten Befehl erstellt wird. Außerdem werden andere Fehlertypen abfangen.

Sie können mehrere trap Anweisungen in einem Skript enthalten. Jeder Fehlertyp kann nur von einer trap Anweisung abgefangen werden. Wenn ein Abbruchfehler auftritt, sucht PowerShell ab dem aktuellen Ausführungsbereich nach der trap spezifischsten Übereinstimmung.

Das folgende Skriptbeispiel enthält einen Fehler. Das Skript enthält eine allgemeine trap Anweisung, die jeden Abbruchfehler abfangen kann, und eine bestimmte trap Anweisung, die den CommandNotFoundException-Typ angibt.

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

Das Ausführen dieses Skripts führt zu folgendem Ergebnis:

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 ein anderes Element erkennt, gibt es einen CommandNotFoundException-Fehler zurück. Dieser Abbruchfehler wird von der spezifischen 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

Das Ausführen dieses Skripts führt zu folgendem Ergebnis:

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

Der Versuch, durch null zu dividieren, erzeugt keinen CommandNotFoundException-Fehler . Stattdessen wird dieser Fehler von der anderen trap Anweisung abgefangen, die jeden Abbruchfehler abfängt.

Abfangen von Fehlern und Bereich

Wenn ein Abbruchfehler im selben Bereich wie die trap -Anweisung auftritt, führt PowerShell die Liste der durch definierten Anweisungen aus trap. Die Ausführung wird nach dem Fehler an der -Anweisung fortgesetzt. 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 gleichen Bereich wie die trap Anweisung befindet.

Wenn beispielsweise ein Fehler in einer Funktion auftritt und die trap Anweisung in der Funktion enthalten ist, wird das Skript bei 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

Das Ausführen dieses Skripts führt zu folgendem Ergebnis:

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 ab. Nach dem Anzeigen der Meldung setzt PowerShell die Ausführung der Funktion fort. Beachten Sie, dass Function1 abgeschlossen wurde.

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

function function2 {
    NonsenseString
    "function2 was completed"
}

trap { "An error: " }

function2

Das Ausführen der Function2 Funktion führt zu folgendem Ergebnis:

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 Abbruchfehler innerhalb der Funktion auf. In diesem Beispiel befindet sich die trap -Anweisung jedoch außerhalb der Funktion. PowerShell wechselt nach der Ausführung der trap Anweisung nicht mehr zur Funktion.

Achtung

Wenn mehrere Traps für dieselbe Fehlerbedingung definiert werden, 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 }

Wichtig

Eine Trap-Anweisung ist auf den Bereich ausgerichtet, an dem sie kompiliert wird. Wenn Sie eine trap -Anweisung in einer Funktion oder einem Dot-Source-Skript haben, werden alle trap Anweisungen entfernt, wenn die Funktion oder das Skript mit Punktquelle beendet wird.

Verwenden der Schlüsselwörter "break and continue"

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

Wenn Sie eine break Anweisung in eine Anweisungsliste trap einschließen, beendet PowerShell die Funktion oder das Skript. Die folgende Beispielfunktion verwendet die break Schlüsselwort (keyword) 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 den break Schlüsselwort (keyword) enthält, wird die Funktion nicht weiter ausgeführt, und die Zeile "Funktion abgeschlossen" wird nicht ausgeführt.

Wenn Sie eine continue Schlüsselwort (keyword) in eine trap -Anweisung einschließen, wird PowerShell nach der Anweisung fortgesetzt, die den Fehler verursacht hat, genau wie ohne break oder continue. Mit dem continue Schlüsselwort (keyword) schreibt PowerShell jedoch keinen Fehler in den Fehlerstream.

Die folgende Beispielfunktion verwendet die continue Schlüsselwort (keyword) 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 "Function completed" wird ausgeführt. Es wird kein Fehler in den Fehlerstream geschrieben.

Hinweise

trap -Anweisungen bieten eine einfache Möglichkeit, um sicherzustellen, dass alle Abbruchfehler innerhalb eines Bereichs behandelt werden. Für eine präzisere Fehlerbehandlung verwenden Sie try/catch Blöcke, in 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 about_Try_Catch_Finally.

Weitere Informationen

about_Break

about_Continue

about_Scopes

about_Throw

about_Try_Catch_Finally