à propos de Trap

Brève description

Décrit un mot-clé qui gère une erreur de fin.

Description longue

Une erreur de fin empêche l’exécution d’une instruction. Si PowerShell ne gère pas une erreur de fin d’une manière ou d’une autre, PowerShell arrête également d’exécuter la fonction ou le script dans le pipeline actuel. Dans d’autres langages, tels que C#, les erreurs de fin sont appelées exceptions.

Le mot clé trap spécifie une liste d’instructions à exécuter lorsqu’une erreur de fin se produit. trap Les instructions peuvent gérer les erreurs de terminaison de la manière suivante :

• Affichez l’erreur après avoir traité le bloc d’instructions trap et continuez l'exécution du script ou de la fonction contenant le trap. Il s’agit du comportement par défaut.

  Remarque

  Lorsque l’erreur de fin se produit dans un bloc de script subordonné, tel qu’une instruction if ou une boucle foreach, les instructions du bloc trap sont exécutées et l’exécution se poursuit à l’instruction suivante en dehors du bloc de script subordonné.

• Affichez l’erreur et abandonnez l’exécution du script ou de la fonction contenant le trap à l’aide de break dans l’instruction trap.

• Silence l’erreur, mais continuer l’exécution du script ou de la fonction contenant le trap à l’aide de continue dans l’instruction trap.

La liste des instructions du trap peut inclure plusieurs conditions ou appels de fonction. Un trap peut écrire des logs, tester des conditions, ou même exécuter un autre programme.

Syntaxe

L’instruction trap a la syntaxe suivante :

trap [[<error type>]] {<statement list>}

L’instruction trap inclut une liste d’instructions à exécuter lorsqu’une erreur de fin se produit. Une instruction trap se compose du mot clé trap, éventuellement suivi d’une expression de type et du bloc d’instructions contenant la liste des instructions à exécuter lorsqu’une erreur est interceptée. L’expression de type affine les types d’erreurs que les trap interceptent.

Un script ou une commande peut avoir plusieurs instructions trap. trap les instructions peuvent apparaître n'importe où dans le script ou la commande.

Trappe de toutes les erreurs de terminaison

Lorsqu’une erreur de fin se produit qui n’est pas gérée d’une autre manière dans un script ou une commande, PowerShell recherche une trap instruction qui gère l’erreur. Si une instruction trap est présente, PowerShell continue d’exécuter le script ou la commande dans l’instruction trap.

L’exemple suivant est une déclaration très simple trap :

trap {"Error found."}

Cette instruction trap intercepte toute erreur de fin.

Dans l’exemple suivant, la fonction inclut une chaîne nonsense qui provoque une erreur d’exécution.

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

TrapTest

L’exécution de cette fonction renvoie les éléments suivants :

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.

L’exemple suivant inclut une instruction trap qui affiche l’erreur à l’aide de la variable automatique $_ :

function TrapTest {
    trap {"Error found: $_"}
    nonsenseString
}

TrapTest

L’exécution de cette version de la fonction renvoie ce qui suit :

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.

Trappe d'erreurs spécifiques

Un script ou une commande peut avoir plusieurs instructions trap. Une trap peut être définie pour gérer des erreurs spécifiques.

L’exemple suivant est une instruction trap qui intercepte l’erreur spécifique CommandNotFoundException:

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

Lorsqu’une fonction ou un script rencontre une chaîne qui ne correspond pas à une commande connue, cette trap instruction affiche la chaîne « Erreur de commande piégée ». Après avoir exécuté la liste des instructions trap, PowerShell écrit l’objet d’erreur dans le flux d’erreurs, puis poursuit le script.

PowerShell utilise des types d’exceptions .NET. L’exemple suivant spécifie le type d’erreur System.Exception :

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

Le type d’erreur CommandNotFoundException hérite du type de System.Exception. Cette instruction intercepte une erreur créée par une commande inconnue. Il intercepte également d’autres types d’erreurs.

Vous pouvez avoir plusieurs instructions trap dans un script. Chaque type d’erreur ne peut être intercepté que par une trap seule instruction. Lorsqu’une erreur de fin se produit, PowerShell recherche le trap avec la correspondance la plus spécifique, en commençant par l’étendue d’exécution actuelle.

L’exemple de script suivant contient une erreur. Le script inclut une instruction trap générale qui intercepte toute erreur de fin et une instruction trap spécifique qui spécifie le type CommandNotFoundException.

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

L’exécution de ce script produit le résultat suivant :

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.

Étant donné que PowerShell ne reconnaît pas « nonsenseString » en tant qu’applet de commande ou autre élément, il retourne une erreur CommandNotFoundException . Cette erreur de fin est interceptée par l’instruction spécifique trap .

L’exemple de script suivant contient les mêmes instructions trap avec une erreur différente :

trap {"Other terminating error trapped" }
trap [System.Management.Automation.CommandNotFoundException]
    {"Command error trapped"}
1/$null

L’exécution de ce script produit le résultat suivant :

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

La tentative de division par zéro ne crée pas d’erreur CommandNotFoundException . Au lieu de cela, cette erreur est piégée par l’instruction other trap , qui intercepte toute erreur de fin.

Trappe des erreurs dans un bloc de script

Par défaut, lorsqu'une erreur de fin est déclenchée, l'exécution passe à l'instruction trap. Une fois le bloc trap exécuté, le contrôle retourne au bloc d’instruction suivant après l’emplacement de l’erreur.

Par exemple, lorsqu’une erreur de fin se produit dans une instruction foreach, l’instruction trap est exécutée et l’exécution se poursuit à l’instruction suivante après le bloc foreach, et non dans le bloc foreach.

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

Dans la sortie ci-dessus, vous pouvez voir les boucles continuer jusqu’à la dernière itération. Lorsque le script tente de diviser 1 par 0, une erreur de fin est générée. Le reste du foreach scriptblock est ignoré, l’instruction try est exécutée et le script continue après le foreach scriptblock.

Erreurs de trappe et portée

Si une erreur de fin se produit dans la même étendue que l’instruction trap , PowerShell exécute la liste des instructions définies par l’instruction trap. L'exécution se poursuit à l'instruction qui suit l'erreur. Si l’instruction trap se trouve dans une portée différente de celle de l’erreur, l’exécution se poursuit à l’instruction suivante qui se trouve dans la même étendue que l’instruction trap .

Par exemple, si une erreur se produit dans une fonction et que l’instruction trap se trouve dans la fonction, le script se poursuit à l’instruction suivante. Le script suivant contient une erreur et une instruction trap :

function function1 {
    trap { "An error: " }
    NonsenseString
    "function1 was completed"
}

function1

L’exécution de ce script produit le résultat suivant :

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

L’instruction trap dans la fonction intercepte l’erreur. Après avoir affiché le message, PowerShell reprend l’exécution de la fonction. Notez que cela Function1 a été terminé.

Comparez cela avec l’exemple suivant, qui contient la même erreur et trap la même déclaration. Dans cet exemple, l’instruction trap se produit en dehors de la fonction :

function function2 {
    NonsenseString
    "function2 was completed"
}

trap { "An error: " }

function2

L’exécution de la fonction Function2 produit le résultat suivant :

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.

Dans cet exemple, la commande « function2 was completed » n’a pas été exécutée. Dans les deux exemples, l’erreur de fin se produit dans la fonction. Dans cet exemple, toutefois, l’instruction trap se trouve en dehors de la fonction. PowerShell ne revient pas dans la fonction après l’exécution de l’instruction trap .

Dans l’exemple suivant, seul le trap avec « whoops 1 » est exécuté.

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

Utilisation des mots clés d’arrêt et de poursuite

Vous pouvez utiliser les mots clés break et continue dans une instruction trap pour déterminer si un script ou une commande continue de s’exécuter après une erreur de fin.

Si vous incluez une instruction break dans une liste d’instructions trap, PowerShell arrête la fonction ou le script. L’exemple de fonction suivant utilise le mot clé break dans une instruction trap :

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.

Étant donné que l’instruction trap incluait le break mot clé, la fonction ne continue pas à s’exécuter et la ligne « Fonction terminée » n’est pas exécutée.

Si vous incluez un mot clé continue dans une instruction trap, PowerShell reprend après l’instruction qui a provoqué l’erreur, comme cela se passerait sans break ou continue. Avec le continue mot clé, cependant, PowerShell n’écrit pas d’erreur dans le flux d’erreurs.

L’exemple de fonction suivant utilise le mot clé continue dans une instruction trap :

function continue_example {
    trap {
        "Error trapped"
        continue
    }
    1/$null
    "Function completed."
}

continue_example

Error trapped
Function completed.

La fonction reprend une fois l’erreur interceptée et l’instruction « Fonction terminée » s’exécute. Aucune erreur n’est écrite dans le flux d’erreurs.

Remarques

trap fournissent un moyen simple de s’assurer que toutes les erreurs de fin d’une étendue sont traitées. Pour une gestion des erreurs plus granulaire, utilisez les blocs try/catch où les pièges sont définis à l’aide d’instructions catch. Les instructions catch s’appliquent uniquement au code à l’intérieur de l’instruction try associée. Pour plus d'informations, voir about_Try_Catch_Finally.

Voir aussi

• about_Break
• about_Continue
• about_Scopes
• about_Throw
• à propos de Try_Catch_Finally