try...catch

Résumé

Cette instruction permet de spécifier un ensemble d'instructions à tenter, et de préciser le traitement à effectuer dans le cas où une exception est produite.

Informations de version

Syntaxe

try {
   try_instructions
}
[catch (exception_var_1 if condition_1) {
   catch_instructions_1
}]
...
[catch (exception_var_2) {
   catch_instructions_2
}]
[finally {
   finally_instructions
}]

Paramètres

try_instructions

Les instructions à exécuter.

catch_instructions_1, catch_instructions_2

Des instructions à exécuter si une exception est produite dans le bloc try .

exception_var_1, exception_var_2

Un identifiant qui permet de représenter l'objet correspondant à l'exception produite.

condition_1

Une expression conditionnelle.

finally_instructions

Des instructions qui sont exécutées une fois l'instruction try terminée. Ces instructions s'exécutent, qu'il y ait eu ou non une exception de produite.

Description

L'instruction try se forme d'un bloc try, contenant une ou plusieurs instructions, et d'au moins : une clause catch ou alors une clause finally, ou les deux. Il y a donc trois formes basiques pour cette instruction.

1. try...catch
2. try...finally
3. try...catch...finally

Une clause catch contient des instructions qui définissent ce qui doit être fait au cas où une exception se produirait dans le bloc try. Autrement dit, le but est de réussir l'ensemble des instructions du bloc try et si jamais cela ne fonctionne pas (c-à-d. une exception se produit), on contrôle le comportement du programme grâce à cette clause. Dans le cas où une instruction du bloc try renvoie une exception, le contrôle passe directement à la clause catch associée. Si aucune exception n'est produite, la clause catch n'est pas utilisée.

La clause finally est exécutée après l'exécution éventuelle des clauses try et catch, mais avant les autres instructions suivant l'instruction try. Elle est toujours exécutée, qu'une exception soit produite ou non.

Il est possible d'imbriquer plusieurs instructions try. Si une instruction try ne possède pas de clause catch, ce sera la clause catch instruction try englobante qui sera utilisée.

Clause catch inconditionnelle

Lorsqu'une seule clause catch est présente, le bloc en question sera utilisé dès qu'une exception, quelconque, sera produite. Ainsi, lorsque l'exception se produit dans le code suivant, le contrôle est passé à la clause catch.

try {
   throw "monException"; // génère une exception
}
catch (e) {
   // instructions gérant n'importe quelle exception
   logErreurs(e); // on passe l'objet d'exception à la fonction gérant les erreurs
}

Clauses catch conditionnelles

Il est également possible d'utiliser une ou plusieurs clauses catch afin de gérer spécifiquement certaines exceptions données. Dans le code qui suit, on peut avoir trois exceptions différentes produites au sein du bloc try : TypeError, RangeError, et EvalError. Si une exception se produit, la clause catch appropriée sera utilisée. Si l'exception ne correspond pas à une de ces clauses et qu'il y a une clause inconditonnelle, ce sera cette dernière clause qui sera utilisée.

Dans ce dernier cas et en général, il faut utiliser la clause inconditionnelle en dernier. En effet, si elle est utilisée avant une clause catch conditionnelle, la clause inconditionnelle « interceptera » les exceptions avant qu'elles puissent être traitées par les clauses suivantes.

try {
   maroutine(); // peut générer trois exceptions
} catch (e if e instanceof TypeError) {
   // instructions dans le cas d'une exception TypeError
} catch (e if e instanceof RangeError) {
   // instructions dans le cas d'une exception RangeError
} catch (e if e instanceof EvalError) {
   // instructions dans le cas d'une exception EvalError
} catch (e) {
   // instructions dans le cas d'autres exceptions
   logErreurs(e); // on passe l'objet exception à la fonction gérant les erreurs
}

Note : Cette fonctionnalité ne fait pas partie de la spécification ECMAScript.

L'identifiant de l'exception

Lorsqu'une exception est produite dans le bloc try, exception_var (ex: le e dans  « catch (e)») contient la valeur donnée par l'instruction throw. Il est possible d'utiliser cet identifiant afin d'obtenir des informations sur l'exception produite en tant qu'objet.

Cet identifiant est local du point de vue de la clause catch. Cela signifie qu'il est créé à l'entrée dans la clause et qu'il n'est plus disponible une fois que la clause a été exécutée.

La clause finally

La clause finally contient les instructions à exécuter après le bloc try et les éventuelles clauses catch et avant les instructions suivant l'instruction try. Elle est exécutée, qu'une exception soit jetée ou non. Si une exception est jetée, les instructions de la clause finally sont exécutées et ce même si aucune clause catch ne gère l'exception produite.

Cette clause peut être utilisée afin qu'un script se termine de manière convenable, même lorsqu'une exception se produit, comme pour relâcher ou fermer une ressource utilisée par le script, comme on peut le voir dans l'exemple qui suit :

ouvrirUnFlux()
try {
   // ouvrir une ressource
   ecrireDansLeFlux(theData);
}
finally {
   fermerLeFlux(); // toujours fermer la ressource
}

Exemple

Voir l'exemple utilisant l'instruction throw.

Voir aussi

• throw
• Error