À propos de l’interruption
Description courte
Décrit une 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 d’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 Trap mot clé spécifie une liste d’instructions à exécuter lorsqu’une erreur de fin se produit. Les instructions trap gèrent les erreurs de fin et permettent à l’exécution du script ou de la fonction de continuer au lieu de s’arrêter.
Les instructions trap peuvent également être plus complexes. La liste d’instructions de l’interruption peut inclure plusieurs conditions ou appels de fonction. Une interruption peut écrire des journaux, des conditions de test ou même exécuter un autre programme.
Syntax
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 de la trap mot clé, éventuellement suivie d’une expression de type, et du bloc d’instruction contenant la liste des instructions à exécuter lorsqu’une erreur est interceptée. L’expression de type affine les types d’erreurs interceptées par l’interruption.
Un script ou une commande peut avoir plusieurs instructions Trap. Les instructions trap peuvent apparaître n’importe où dans le script ou la commande.
Piégeage de toutes les erreurs de fin
Lorsqu’une erreur de fin qui n’est pas gérée d’une autre manière dans un script ou une commande se produit, PowerShell recherche une instruction Trap 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 instruction Trap très simple :
trap {"Error found."}
Cette instruction Trap intercepte toute erreur de fin.
Dans l’exemple suivant, la fonction inclut une chaîne non sensé qui provoque une erreur d’exécution.
function TrapTest {
trap {"Error found."}
nonsenseString
}
TrapTest
L’exécution de cette fonction retourne ce qui suit :
Error found.
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 retourne 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 then try
again.
Important
Les instructions trap peuvent être définies n’importe où dans une étendue donnée, mais s’appliquent toujours à toutes les instructions de cette étendue. Au moment de l’exécution, les interruptions dans un bloc sont définies avant l’exécution de toutes les autres instructions. En JavaScript, c’est ce qu’on appelle le levage. Cela signifie que les interruptions s’appliquent à toutes les instructions de ce bloc même si l’exécution n’a pas dépassé le point où elles sont définies. Par exemple, la définition d’une interruption à la fin d’un script et la levée d’une erreur dans la première instruction déclenchent toujours cette interruption.
Piégeage d’erreurs spécifiques
Un script ou une commande peut avoir plusieurs instructions Trap. Les interruptions peuvent être définies 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 instruction Trap affiche la chaîne « Erreur de commande piégée ». Après avoir exécuté la Trap liste des instructions, PowerShell écrit l’objet d’erreur dans le flux d’erreurs, puis continue le script.
PowerShell utilise les types d’exception Microsoft .NET Framework. 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 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 bloqué que par une seule instruction Trap. Lorsqu’une erreur de fin se produit, PowerShell recherche l’interruption avec la correspondance la plus spécifique, en commençant par l’étendue actuelle de l’exécution.
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 spécifique Trap 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 : 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.
At C:\temp\test\traptest.ps1:5 char:1
+ nonsenseString
+ ~~~~~~~~~~~~~~
+ CategoryInfo : ObjectNotFound: (nonsenseString:String) [], CommandNotFoundException
+ FullyQualifiedErrorId : CommandNotFoundException
É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 piégée par l’instruction Trap spécifique.
L’exemple de script suivant contient les mêmes instructions Trap avec une autre erreur :
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
Attempted to divide by zero.
At C:\temp\test\traptest.ps1:5 char:1
+ 1/$null
+ ~~~~~~~
+ CategoryInfo : NotSpecified: (:) [], RuntimeException
+ FullyQualifiedErrorId : RuntimeException
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’autre instruction Trap, qui intercepte toute erreur de fin.
Piégeage des erreurs et de l’étendue
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’interruption. L’exécution se poursuit au niveau de l’instruction après l’erreur. Si l’instruction Trap se trouve dans une étendue différente de l’erreur, l’exécution se poursuit à l’instruction suivante qui est 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 continue à l’instruction suivante. Le script suivant contient une instruction d’erreur et d’interruption :
function function1 {
trap { "An error: " }
NonsenseString
"function1 was completed"
}
Plus loin dans le script, l’exécution de la fonction Function1 produit le résultat suivant :
function1
An error:
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
then try again.
At C:\PS>TestScript1.ps1:3 char:19
+ NonsenseString <<<<
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 Function1 a été terminé.
Comparez cela à l’exemple suivant, qui a la même erreur et Trap la même instruction. 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 Function2 fonction produit le résultat suivant :
An error:
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
then try again.
At C:\PS>TestScript2.ps1:4 char:19
+ NonsenseString <<<<
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 retourne pas dans la fonction après l’exécution de l’instruction Trap.
Attention
Lorsque plusieurs interruptions sont définies pour la même condition d’erreur, la première interruption définie lexicalement (la plus élevée dans l’étendue) est utilisée.
Dans l’exemple suivant, seul le piège avec « whoops 1 » est exécuté.
Remove-Item -ErrorAction Stop ThisFileDoesNotExist
trap { "whoops 1"; continue }
trap { "whoops 2"; continue }
Utilisation des break mots clés et continue
Vous pouvez utiliser les Break mots clés 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 Break instruction dans une liste d’instructions Trap, PowerShell arrête la fonction ou le script. L’exemple de fonction suivant utilise le Break mot clé dans une instruction Trap :
function break_example {
trap {
"Error trapped"
break
}
1/$null
"Function completed."
}
break_example
Error trapped
Attempted to divide by zero.
At line:4 char:7
É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 une Continue instruction dans une instruction Trap, PowerShell reprend après l’instruction qui a provoqué l’erreur, comme il le ferait sans Break ou Continue. Toutefois, avec le Continue mot clé, PowerShell n’écrit pas d’erreur dans le flux d’erreurs.
L’exemple de fonction suivant utilise le Continue mot clé dans une Trap instruction :
function continue_example {
trap {
"Error trapped"
continue
}
1/$null
"Function completed."
}
continue_example
Error trapped
Function completed.
La fonction reprend une fois l’erreur bloquée et l’instruction « Function completed » s’exécute. Aucune erreur n’est écrite dans le flux d’erreurs.
Notes
Les instructions d’interruption fournissent un moyen simple de s’assurer que toutes les erreurs de fin d’une étendue sont gérées. Pour une gestion plus fine des erreurs, utilisez try/catch des blocs où les interruptions sont définies à l’aide d’instructions.Catch Les Catch instructions s’appliquent uniquement au code à l’intérieur de l’instruction associée Try . Pour plus d’informations, consultez about_Try_Catch_Finally.