Freigeben über

about_Trap

  • Artikel

Kurze Beschreibung

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

Lange Beschreibung

Ein Abbruchfehler stoppt die Ausführung einer Anweisung. Wenn PowerShell einen Abbruchfehler 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 Abschlussfehler 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 können die Beendigungsfehler auf folgende Weise behandeln:

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

    Hinweis

    Wenn der Abbruchfehler in einem untergeordneten Skriptblock auftritt, z. B. in einer if Anweisung oder foreach Schleife, werden die Anweisungen im Block ausgeführt, und die trap 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 ab, die den trap using break in der trap -Anweisung enthält.

  • Beenden Sie den Fehler, aber fahren Sie mit der Ausführung des Skripts oder der Funktion fort, das den trapcontinue in der trap -Anweisung enthält.

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 verfeinern die Fehlertypen, die von den trap Abfängen erfasst werden.

Ein Skript oder 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

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.

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 für alle Anweisungen in diesem Block gelten, auch wenn die Ausführung nicht über den Punkt hinaus fortgeschritten ist, an dem sie definiert werden. Wenn Sie z. B. ein trap am Ende eines Skripts definieren und einen Fehler in der ersten Anweisung auslösen, wird dies trapweiterhin ausgelöst.

Abfangen bestimmter Fehler

Ein Skript oder 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 stößt, 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 mehr als eine trap Anweisung 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 mit der spezifischsten Übereinstimmung.

Das folgende Skriptbeispiel enthält einen Fehler. Das Skript enthält eine allgemeine trap Anweisung, die jeden Abbruchfehler abfängt, 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 dieselben 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, führt nicht zu einem CommandNotFoundException-Fehler . Stattdessen wird dieser Fehler von der anderen trap Anweisung abgefangen, die jeden Abbruchfehler abfängt.

Abfangen von Fehlern in einem Skriptblock

Wenn ein Abbruchfehler ausgelöst wird, wird die Ausführung standardmäßig an die trap-Anweisung übertragen. Nachdem der trap Block ausgeführt wurde, kehrt das Steuerelement zum nächsten Anweisungsblock nach dem Speicherort des Fehlers zurück.

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

Abfangfehler und -bereich

Wenn ein Abbruchfehler im selben Bereich wie die trap -Anweisung auftritt, führt PowerShell die Liste der anweisungen aus, die trapdurch definiert werden. 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 sich die trap -Anweisung in der -Funktion befindet, 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 auf. Nach dem Anzeigen der Meldung wird die Funktion von PowerShell fortgesetzt. Beachten Sie, dass Function1 abgeschlossen war.

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 war abgeschlossen" 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 ausführung der Anweisung nicht mehr in die trap Funktion zurück.

Achtung

Wenn mehrere Traps für dieselbe Fehlerbedingung definiert werden, wird die erste trap definierte lexikalische (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 über eine trap Anweisung in einer Funktion oder einem Skript mit Punktquelle verfügen, werden alle trap darin enthaltenen Anweisungen entfernt, wenn die Funktion oder das skript, das vom Punkt stammt, 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 Befehl nach einem Beendigungsfehler weiterhin ausgeführt wird.

Wenn Sie eine break Anweisung in eine Anweisungsliste trap aufnehmen, 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 mehr 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 im Großen und Ganzen sicherzustellen, dass alle Abbruchfehler innerhalb eines Bereichs behandelt werden. Für eine genauere 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