Freigeben über

about_Trap

  • Artikel

Kurze Beschreibung

Beschreibt ein Schlüsselwort, das einen Beendigungsfehler behandelt.

Lange Beschreibung

Ein Beendigungsfehler 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 trap Schlüsselwort gibt eine Liste von Anweisungen an, die ausgeführt werden sollen, wenn ein Beendigungsfehler auftritt. trap Anweisungen können die Beendigungsfehler auf folgende Weise behandeln:

  • Zeigt den Fehler nach der Verarbeitung des trap Anweisungsblocks an und setzt die Ausführung des Skripts oder der Funktion fort, das die trap. 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.

  • Zeigt den Fehler an und bricht die Ausführung des Skripts oder der Funktion ab, das die trap Verwendung break in der trap Anweisung enthält.

  • Stillen Sie den Fehler, aber setzen Sie die Ausführung des Skripts oder der Funktion fort, das die trap in der trap Anweisung verwendetcontinue.

Die Anweisungsliste der trap Kann mehrere Bedingungen oder Funktionsaufrufe enthalten. A trap can write logs, test conditions, or even run another program.

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, der die Liste der auszuführenden Anweisungen enthält, wenn ein Fehler abgefangen wird. Der Typausdruck verfeinern die Fehlertypen, die die trap Abfangen aufweisen.

Ein Skript oder Ein Befehl kann mehrere trap Anweisungen aufweisen. trap Anweisungen können an einer beliebigen Stelle im Skript oder Befehl angezeigt werden.

Abfangen aller Abbruchfehler

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.

Das folgende Beispiel ist eine minimale trap Anweisung:

trap { 'Error found.' }

Diese trap Anweisung fängt alle Beendigungsfehler auf.

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.

Wichtig

trap Anweisungen können an einer beliebigen Stelle innerhalb eines bestimmten Skriptblocks definiert werden, gelten jedoch immer für alle Anweisungen in diesem Skriptblock. Zur Laufzeit werden Anweisungen in einem Block definiert, trap bevor andere Anweisungen ausgeführt werden. In JavaScript wird dies als Hebezeugung 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 sind. Wenn Sie z. B. ein trap Skript 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 Ein Befehl kann mehrere trap Anweisungen aufweisen. Eine trap kann definiert werden, um bestimmte Fehler zu behandeln.

The following example is a trap statement that traps the specific error CommandNotFoundException:

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 Fehlertyp "System.Exception " angegeben:

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

Der CommandNotFoundException-Fehlertyp erbt vom Typ "System.Exception" . Diese Anweisung fängt alle Fehler auf, die von unbekannten Befehlen ausgelöst werden. Außerdem fallen andere Fehlertypen auf.

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 mehrere trap Anweisungen in einem Skript haben. Nur eine trap Anweisung kann jeden Fehlertyp abfangen. Wenn ein Beendigungsfehler auftritt, sucht PowerShell nach der trap spezifischsten Übereinstimmung, beginnend mit dem aktuellen Skriptblock der Ausführung.

Das folgende Skriptbeispiel enthält einen Fehler. Das Skript enthält eine allgemeine trap Anweisung, mit der alle Beendigungsfehler und eine bestimmte trap Anweisung erfasst werden, 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 nicht als Cmdlet oder ein anderes Element erkannt nonsenseString wird, wird ein CommandNotFoundException-Fehler zurückgegeben. Die spezifische trap Anweisung fängt diesen Beendigungsfehler 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 dividiert zu werden, erstellt keinen CommandNotFoundException-Fehler . Die andere trap Anweisung, die einen endenden Fehler auffangt, fängt die Division durch null Fehler auf.

Abfangen von Fehlern in einem Skriptblock

Wenn ein Beendigungsfehler ausgelöst wird, wird die Ausführung standardmäßig an die Trap-Anweisung übertragen. 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 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..-1) {
       "1/$x = "
       "`t$(1/$x)"
}
'after loop'

1/3 =
        0.333333333333333
1/2 =
        0.5
1/1 =
        1
1/0 =
An error occurred!
RuntimeException:
Line |
   4 |         "`t$(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 foreach Skriptblock fortgesetzt.

Abfangen von Fehlern und Umfang

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

Durch ausführen der Function2 Funktion 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 function2 was completed Befehl 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 nach ausführung der trap Anweisung nicht zurück zur Funktion.

Achtung

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

Im folgenden Beispiel wird nur die trap Ausführung ausgeführt whoops 1 .

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

Wichtig

Eine trap Anweisung ist auf die Stelle, an der sie kompiliert wird, definiert. Wenn Sie eine trap Anweisung innerhalb einer Funktion oder eines dot-sourced-Skripts haben, werden alle trap darin enthaltenen Anweisungen entfernt, wenn die Funktion oder das gepunktete Skript beendet wird.

Verwenden der Umbruch- und Fortsetzungsstichwörter

Mit den break Schlüsselwörtern und continue Schlüsselwörtern in einer trap Anweisung können Sie ermitteln, ob ein Skript oder Befehl nach einem Beendigungsfehler weiterhin ausgeführt wird.

Wenn Sie eine break Anweisung in eine trap Anweisungsliste einschließen, beendet PowerShell die Funktion oder das Skript. Die folgende Beispielfunktion verwendet das break Schlüsselwort 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 Function completed Zeile wird nicht ausgeführt.

Wenn Sie ein continue Schlüsselwort in eine trap Anweisung einschließen, wird PowerShell nach der Anweisung fortgesetzt, die den Fehler verursacht hat, genauso wie es ohne break oder continue. Bei dem continue Schlüsselwort schreibt PowerShell jedoch keinen Fehler in den Fehlerdatenstrom.

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

function ContinueExample {
    trap {
        'Error trapped'
        continue
    }
    foreach ($x in 3..-1) {
       "1/$x = "
       "`t$(1/$x)"
    }
    'End of function'
}

ContinueExample

1/3 =
        0.333333333333333
1/2 =
        0.5
1/1 =
        1
1/0 =
Error trapped
End of function

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

Hinweise

trap Anweisungen bieten eine Möglichkeit, um sicherzustellen, dass alle Beendigungsfehler innerhalb eines Skriptblocks behandelt werden. Verwenden Sie try/catch für eine genauere Fehlerbehandlung 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 about_Try_Catch_Finally.

Siehe auch