Guide JavaScript 1.5:Instructions de gestion d'exceptions:L'instruction try...catch
Un article de MDC.
Sommaire |
[modifier] L'instruction try...catch
L'instruction try...catch indique un bloc d'instructions à essayer, et spécifie une ou plusieurs réponses à apporter en cas d'exception. Si une exception se produit, l'instruction try...catch la prend en charge.
L'instruction try...catch consiste en un bloc try, contenant une ou plusieurs instructions, et zéro ou plus blocs catch, contenant des instructions spécifiant ce qu'il faut faire si une exception est rencontrée au sein du bloc try. Autrement dit, vous désirez que ce qui se trouve dans le bloc try fonctionne, et si cela ne fonctionne pas, que le contrôle passe au bloc catch. Dès qu'une instruction au sein du bloc try (ou dans une fonction appelée depuis le bloc try) provoque une exception, le contrôle passe immédiatement au bloc catch. Si aucune exception ne se produit dans le bloc try, le bloc catch est passé. Le bloc finally est exécuté après les blocs try et catch, mais avant l'instruction qui suit l'instruction try...catch.
L'exemple suivant utilise une instruction try...catch. Il appelle une fonction qui retrouve le nom du mois dans un tableau selon la valeur passée en paramètre. Si la valeur ne correspond pas à un numéro de mois (1-12), une exception est provoquée avec la valeur NumMoisInvalide, et les instructions dans le bloc catch positionnent la variable nomMois à inconnu.
function trouveNomMois (mo) {
mo = mo-1; // Ajuste le numéro pour correspondre à un index de tableau (1=Jan, 12=Déc)
var mois = new Array("Jan","Fév","Mar","Avr","Mai","Jun","Jul",
"Aoû","Sep","Oct","Nov","Déc");
if (mois[mo] != null) {
return mois[mo]
} else {
throw "NumMoisInvalide"
}
}
try {
// instructions à essayer
nomMois = trouveNomMois(monMois) // la fonction peut provoquer une exception
}
catch (e) {
nomMois = "inconnu"
logDesErreurs(e) // passe l'objet exception à la gestion d'erreurs
}
[modifier] Le bloc catch
Vous pouvez utiliser un seul bloc catch pour gérer toutes les exceptions qui pourraient être générées dans le bloc try, ou vous pouvez utiliser des blocs catch séparés pour chaque type d'exception particulier.
Un seul bloc catch
Utilisez un seul bloc catch au sein d'une instruction try...catch pour faire une gestion d'erreurs sur toute exception provoquée dans le bloc try.
La syntaxe d'un seul bloc catch est la suivante :
catch (catchID) {
instructions
}
Le bloc catch spécifie un identifiant (catchID dans l'exemple ci-dessus) qui contient la valeur spécifiée par l'instruction throw ; celui-ci peut être utilisé pour obtenir plus d'informations sur l'exception qui s'est produite. JavaScript crée cet identifiant à l'entrée du bloc catch ; celui-ci existe uniquement au sein du bloc catch ; dès que l'exécution du bloc catch se termine, l'identifiant n'est plus disponible.
Par exemple, le code suivant provoque une exception. Lorsqu'elle survient le contrôle passe au bloc catch.
try {
throw "monException" // génère une exception
}
catch (e) {
// instructions gérant toute exception
logDesErreurs(e) // passe l'objet d'exception à la gestion d'erreurs
}
Blocs catch multiples
Un bloc try individuel peut contenir plusieurs blocs catch, chacun gérant un type spécifique d'exception. Dans ce cas, le bloc catch approprié est exécuté seulement lorsque l'exception spécifiée pour ce bloc est provoquée. Il est également possible d'ajouter un bloc catch universel pour tous les types d'exceptions non spécifiés comme dernier bloc de l'instruction.
Par exemple, la fonction suivante invoque trois autres fonctions (déclarées ailleurs), qui valident ses paramètres. Si une des fonctions de validation détermine que la partie qu'elle vérifie est invalide, elle renvoie 0, ce qui génère une exception particulière dans la fonction appelante.
function infosPerso(nom, id, email)
{
var n, i, e;
if (!valide_nom(nom))
throw "ExceptionNomInvalide"
else
n = nom;
if (!valide_id(id))
throw "ExceptionIdInvalide"
else
i = id;
if (!valide_email(email))
throw "ExceptionEmailInvalide"
else
e = email;
personne = (n + " " + i + " " + e);
return (personne);
}
Les blocs catch conditionnels font passer le contrôle au gestionnaire d'erreurs approprié.
try {
// la fonction peut générer trois types d'exceptions
infosPerso("Dupond", 1234, "dupont@laposte.net")
}
catch (e if e == "ExceptionNomInvalide") {
// Appelle la gestion de noms invalides
gestion_nom_invalide(e)
}
catch (e if e == "ExceptionIdInvalide") {
// Appelle la gestion d'id invalides
gestion_id_invalide(e)
}
catch (e if e == "ExceptionEmailInvalide") {
// appelle la gestion d'e-mails invalides
gestion_email_invalide(e)
}
catch (e){
// on ne sait pas quoi faire de l'erreur, mais on l'ajoute dans le log
logErreur(e)
}
[modifier] Le bloc finally
Le bloc finally contient des instructions à exécuter après les autres blocs de l'instruction try...catch, mais avant les instructions qui suivent. Le bloc finally est exécuté qu'une exception survienne ou non. Si une exception est provoquée, les instructions dans le bloc finally sont exécutées même si aucun bloc catch n'a pu gérer l'exception.
Vous pouvez utiliser le bloc finally pour que votre script se termine correctement lorsqu'une exception a lieu ; par exemple, en libérant une ressource que le script avait réservée. L'exemple suivant ouvre un fichier et exécute ensuite des instructions utilisant le fichier (le JavaScript côté serveur permet d'accéder à des fichiers). Si une exception survient pendant que le fichier est ouvert, le bloc finally fermera le fichier avant qu'il se termine.
ouvreFichier();
try {
ecrireDansFichier(donnees); // ceci peut provoquer une exception
}
catch (e) {
gestionErreur(e); // en cas d'erreur, on la gère
}
finally {
fermeFichier(); // ferme toujours la ressource
}
[modifier] Instructions try...catch imbriquées
Il est possible d'imbriquer un ou plusieurs blocs try...catch. Si l'instruction d'un bloc try...catch imbriqué n'a pas de bloc catch, les blocs catch de l'instruction try...catch parente seront vérifiés pour voir s'ils ne correspondent pas.