about_Trap
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. trap
les instructions peuvent gérer les erreurs de fin des manières suivantes :
Affichez l’erreur après le traitement du
trap
bloc d’instructions et la poursuite de l’exécution du script ou de la fonction contenant letrap
. Il s’agit du comportement par défaut.Notes
Lorsque l’erreur de fin se produit dans un bloc de script subordonné, tel qu’une instruction ou
foreach
uneif
boucle, les instructions du bloc sont exécutées et l’exécutiontrap
se poursuit à l’instruction suivante en dehors du bloc de script subordonné.Affichez l’erreur et annulez l’exécution du script ou de la fonction contenant l’utilisation
trap
break
dans l’instructiontrap
.Faites taire l’erreur, mais poursuivez l’exécution du script ou de la fonction contenant le
trap
en utilisantcontinue
dans l’instructiontrap
.
La liste d’instructions de peut trap
inclure plusieurs conditions ou appels de fonction. Un trap
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 trap
instruction se compose de la trap
mot clé, éventuellement suivie 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 trap
interceptés.
Un script ou une commande peut avoir plusieurs trap
instructions. trap
les instructions 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 trap
instruction qui gère l’erreur. Si une trap
instruction est présente, PowerShell continue d’exécuter le script ou la commande dans l’instruction trap
.
L’exemple suivant est une instruction minimale trap
:
trap { 'Error found.' }
Cette trap
instruction 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 la sortie suivante :
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.
L’exemple suivant inclut une trap
instruction 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 la sortie suivante :
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.
Important
trap
les instructions peuvent être définies n’importe où dans un bloc de script donné, mais s’appliquent toujours à toutes les instructions de ce bloc de script. Au moment de l’exécution, trap
les instructions d’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 trap
les instructions 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’un trap
à la fin d’un script et la levée d’une erreur dans la première instruction déclenche toujours que trap
.
Piégeage d’erreurs spécifiques
Un script ou une commande peut avoir plusieurs trap
instructions. Un trap
peut être défini pour gérer des erreurs spécifiques.
L’exemple suivant est une trap
instruction 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 Command error trapped
chaîne.
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 des types d’exception .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 System.Exception . Cette instruction intercepte toutes les erreurs générées par des commandes inconnues. Il intercepte également d’autres types d’erreurs.
Vous pouvez trouver le type d’exception d’une erreur en inspectant l’objet d’erreur. L’exemple suivant montre comment obtenir le nom complet de l’exception pour la dernière erreur dans une session :
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
Vous pouvez avoir plusieurs trap
instructions dans un script. trap
Une seule instruction peut intercepter chaque type d’erreur. Lorsqu’une erreur de fin se produit, PowerShell recherche le trap
avec la correspondance la plus spécifique, en commençant dans le bloc de script actuel d’exécution.
L’exemple de script suivant contient une erreur. Le script comprend une instruction générale trap
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:
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.
Étant donné que PowerShell ne reconnaît nonsenseString
pas en tant qu’applet de commande ou autre élément, il retourne une erreur CommandNotFoundException . L’instruction spécifique trap
intercepte cette erreur de fin.
L’exemple de script suivant contient les mêmes trap
instructions 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 |
5 | 1/$null
| ~~~~~~~
| Attempted to divide by zero.
La tentative de division par zéro ne crée pas d’erreur CommandNotFoundException . L’autre trap
instruction, qui intercepte toute erreur de fin, intercepte l’erreur diviser par zéro.
Piégeage des erreurs dans un bloc de script
Par défaut, lorsqu’une erreur de fin est levée, l’exécution est transférée vers l’instruction d’interruption. Une fois le bloc exécuté, le trap
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 foreach
instruction, l’instruction est exécutée et l’exécution trap
se poursuit à l’instruction suivante après le foreach
bloc, et non dans le foreach
bloc.
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
Dans la sortie, vous pouvez voir les boucles continuer jusqu’à la dernière itération. Lorsque le script tente de diviser 1 par 0, PowerShell génère une erreur de fin. Le script ignore le reste du bloc de foreach
script, exécute l’instruction try
et continue après le bloc de foreach
script.
Piégeage des erreurs et de l’étendue
Si une erreur de fin se produit dans le même bloc de script que l’instructiontrap
, PowerShell exécute la liste des instructions définies par .trap
L’exécution se poursuit au niveau de l’instruction après l’erreur. Si l’instruction trap
se trouve dans un bloc de script différent de l’erreur, l’exécution se poursuit à l’instruction suivante qui se trouve dans le même bloc de script 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 erreur et une trap
instruction :
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 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
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 terminé Function1
après l’instruction trap
.
Comparez ce comportement avec 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:
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.
Dans cet exemple, la function2 was completed
commande 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 trap
définie lexicalement (la plus élevée dans le bloc de script) est utilisée.
Dans l’exemple suivant, seul le avec whoops 1
s’exécutetrap
.
Remove-Item -ErrorAction Stop ThisFileDoesNotExist
trap { 'whoops 1'; continue }
trap { 'whoops 2'; continue }
Important
Une trap
instruction est limitée à l’emplacement où elle se compile. Si vous avez une trap
instruction à l’intérieur d’une fonction ou d’un script source de points, lorsque le script source de fonction ou de point se termine, toutes les trap
instructions à l’intérieur sont supprimées.
Utilisation des mots clés d’arrêt et de poursuite
Vous pouvez utiliser les break
mots clés et continue
dans une trap
instruction 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 trap
instruction :
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 Function completed
ligne n’est pas exécutée.
Si vous incluez un continue
mot clé dans une trap
instruction, PowerShell reprend après l’instruction à l’origine de 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
exécutée. Aucune erreur n’est écrite dans le flux d’erreurs.
Notes
trap
les instructions permettent de garantir que toutes les erreurs de fin au sein d’un bloc de script 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.