Ü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 auf irgendeine Weise nicht verarbeitet, 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. Dieses Verhalten ist die Standardeinstellung.

  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 eine 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.

Im Folgenden sehen Sie ein Beispiel für eine minimale 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

Wenn Sie diese Funktion ausführen, wird die folgende Ausgabe zurückgegeben:

Error found.
nonsenseString:
Line |
   3 |      nonsenseString
     |      ~~~~~~~~~~~~~~
     | The term 'nonsenseString' is not recognized as a name of a cmdlet,
function, script file, or executable 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 die folgende Ausgabe 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 a name of a cmdlet,
function, script file, or executable program.
Check the spelling of the name, or if a path was included, verify that the
path is correct and try again.

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 Command error trapped Zeichenfolge 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 alle Fehler auf, die von unbekannten Befehlen ausgelöst werden. Sie fängt auch andere Fehlertypen ab.

Sie finden den Ausnahmetyp für einen Fehler, indem Sie das Fehlerobjekt prüfen. Das folgende Beispiel zeigt, wie der vollständige Name der Ausnahme für den letzten Fehler in einer Sitzung abgerufen wird.

nonsenseString
$Error[0].Exception.GetType().FullName

nonsenseString: The term 'nonsenseString' is not recognized as a name of a
cmdlet, function, script file, or executable program. Check the spelling
of the name, or if a path was included, verify that the path is correct
and try again.

System.Management.Automation.CommandNotFoundException

Sie können für ein Skript mehrere trap-Anweisungen festlegen. Nur eine trap-Anweisung kann jeden Fehlertyp abfangen. Tritt ein Fehler mit Abbruch auf, sucht PowerShell ausgehend vom aktuellen Skriptbock der Ausführung nach dem spezifischsten trap.

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 a name of a cmdlet,
function, script file, or executable 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, wird ein CommandNotFoundException Fehler zurückgegeben. Die spezifische trap-Anweisung fängt diesen Fehler mit Abbruch auf.

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

Der Versuch, durch Null zu dividieren, erstellt keinen CommandNotFoundException Fehler. Die andere trap-Anweisung, die alle Fehler mit Abbruch abfängt, fängt den Fehler aufgrund einer Division durch 0 (null) ab.

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:
Line |
   3 |     1/$x
     |     ~~~~
     | Attempted to divide by zero.
after loop

In der Ausgabe können Sie sehen, dass die Schleifen bis zur letzten Iteration fortgesetzt werden. Wenn das Skript versucht, 1 um 0 zu dividieren, löst PowerShell einen Beendigungsfehler aus. Das Skript überspringt den rest des foreach Skriptblocks, führt die try-Anweisung aus und wird nach dem skriptblock foreach fortgesetzt.

Abfangen von Fehlern und Geltungsbereich

Wenn ein Beendigungsfehler im gleichen Skriptblock wie die trap-Anweisung auftritt, führt PowerShell die Liste der vom trapdefinierten Anweisungen aus. Die Ausführung wird nach der Anweisung fortgesetzt, die auf den Fehler folgt. Wenn sich die trap-Anweisung in einem anderen Skriptblock als der Fehler befindet, wird die Ausführung bei der nächsten Anweisung fortgesetzt, die sich im gleichen Skriptblock 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 a name of a cmdlet,
function, script file, or executable 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 Function1 nach der trap-Anweisung abgeschlossen wurde.

Vergleichen Sie dieses Verhalten mit dem folgenden Beispiel, das denselben Fehler und trap 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 a name of a cmdlet,
function, script file, or executable 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 wechselt nicht zurück zur Funktion, nachdem die trap-Anweisung ausgeführt wird.

Im folgenden Beispiel wird nur die trap-Anweisung mit whoops 1 ausgeführt.

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

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 schlüsselwort break enthält, wird die Funktion nicht weiter ausgeführt, und die Function completed Zeile 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 Schlüsselwort continue schreibt PowerShell jedoch keinen Fehler in den Fehlerdatenstrom.

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 Function completed wird ausgeführt. Es wird kein Fehler in den Fehlerdatenstrom geschrieben.

Hinweise

trap Anweisungen bieten eine Möglichkeit, sicherzustellen, dass alle Beendigungsfehler innerhalb eines Skriptblocks 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