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 minimale 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 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 aber 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 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 Command error trapped Zeichenfolge 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 alle Fehler ab, die von unbekannten Befehlen ausgelöst werden. Außerdem werden andere Fehlertypen abfangen.

Sie können den Ausnahmetyp für einen Fehler ermitteln, indem Sie das Fehlerobjekt überprüfen. Das folgende Beispiel zeigt, wie Sie den vollständigen Namen der Ausnahme für den letzten Fehler in einer Sitzung abrufen:

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 mehr als eine trap Anweisung in einem Skript enthalten. Nur eine trap Anweisung kann jeden Fehlertyp abfangen. Wenn ein Abbruchfehler auftritt, sucht PowerShell nach dem trap mit der 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, 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 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, gibt es einen CommandNotFoundException-Fehler zurück. Die spezifische trap Anweisung fängt diesen Abbruchfehler ab.

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

Der Versuch, durch null zu dividieren, führt nicht zu einem CommandNotFoundException-Fehler . Die andere trap Anweisung, die jeden Abbruchfehler abfängt, fängt die Aufteilung durch null Fehler ab.

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

In der Ausgabe sehen Sie, dass die Schleifen bis zur letzten Iteration fortgesetzt werden. Wenn das Skript versucht, 1 durch 0 zu teilen, löst PowerShell einen Abbruchfehler aus. Das Skript überspringt den Rest des foreach Skriptblocks, führt die try Anweisung aus und fährt nach dem foreach Skriptblock fort.

Abfangfehler und -bereich

Wenn im selben Skriptblock wie die trap -Anweisung ein Abbruchfehler auftritt, führt PowerShell die Liste der durch definierten trapAnweisungen 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 selben 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 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 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 Meldung wird die Funktion von PowerShell fortgesetzt. 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

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

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

Achtung

Wenn mehrere Traps für dieselbe Fehlerbedingung definiert werden, wird die erste trap definierte lexikalische (höchste im Skriptblock) 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 weiter ausgeführt, und die Function completed Zeile 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 Function completed Anweisung ausgeführt wird. Es wird kein Fehler in den Fehlerstream geschrieben.

Hinweise

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