SELFHTML: JavaScript / Exemples d'application / Traitement d'erreur avec la commande try..catch

SELFHTML/Aides à la navigation

JavaScript/DOM

Exemples d'application

Traitement d'erreur avec la commande try..catch

Remarques sur cet exemple
Texte source avec explications

Exemple d'affichage: aperçu

Remarques sur cet exemple

À l'aide du Traitement d'erreur avec le gestionnaire d'événement onError vous pouvez intercepter des erreurs dans un JavaScript après que celle-ci est survenue. Avec la méthode présentée ici, vous pouvez cependant empêcher d'emblée que des erreurs surviennent dans des situations critiques. Pour cela vous disposez, depuis la version 1.5 JavaScript, de l'instruction try..catch. Elle vous permet de vérifier des variables et des valeurs et de réagir selon le résultat. Cette instruction est interprétée par l'Explorer Internet MS à partir de la version 5.0, par Netscape à partir de la version 6.0 et par Opera à partir de la version 5.

Texte source avec explications

L'exemple est construit de telle façon qu'il accède à une variable qui dans un premier temps n'existe pas du tout. Cela conduirait à une erreur. Le script "sait" cependant qu'une telle erreur peut intervenir et vérifie pour cette raison sans arrêt avec l'instruction try..catch si la variable existe déjà. Ce n'est que lorsque la variable existe que la surveillance s'achève.

Exemple:

Exemple d'affichage: aperçu

<html><head><title>Test</title>
<script type="text/javascript">
<!--

setTimeout("x=3",200);

function affiche_resultat(compteur,resultat)
 {
   alert("Après "+(compteur)+ " passages, x existait x.\nLe nombre x est "+resultat+".");
 }

function teste_x(compteur)
{
 try {
 if (x==2) throw "correct";
 else if (x==3) throw "faux";
 }
 catch (e) {
     if (e=="correct") {affiche_resultat(compteur,e);return;}
     else if (e=="faux") {affiche_resultat(compteur,e);return;}
     }
 finally { compteur++; }

setTimeout('teste_x('+(compteur)+')',30);

}
teste_x(0)
//-->
</script>
</head><body>
</body></html>

Explication:

Dans l'entête du fichier est noté un passage Script. En sont exécutées à la ecture du fichier la première et la dernière instruction. Les autres instructions se trouvent dans des fonctions.

La variable x

Pendant le chargement du fichier, une variable x se voit affecter la valeur 3 avec un décalage dans le temps. C'est ce à quoi sert la méthode setTimeout(). La variable n'est donc disponible qu'après 200 millièmes de seconde. Chaque tentative pour accéder avant cela à cette variable conduirait à une erreur.

L'instruction suivante qui dans l'exemple est exécutée d'emblée est la dernière du passage script, à savoir teste_x(0). Grâce à elle la fonction teste_x(), notée au dessus, est appelée.

La fonction teste_x()

Cette fonction tente d'accéder à la variable x. Étant donné qu'à l'appel de la fonction, il n'est cependant pas encore sûr que la variable x existe déjà, l'instruction try..catch pour éviter les messages d'erreurs est notée dans la fonction.
Lorsqu'elle est appelée, la fonction teste_x() reçoit un paramètre nommé compteur qui lui est transmis. cela sert dans l'exemple aux fins de contrôle.

Construction de l'instruction `try`..`catch`

L'instruction try..catch a en général la construction suivante: Après le mot-clé try (try = essayer) une parenthèse accolade d'ouverture, suivie de la condition à vérifier est notée. Selon les besoins, vous pouvez ensuite définir vos propres erreurs avec throw (throw = jeter). La définition throw est toutefois facultative. Enfin suit une parenthèse accolade de fermeture qui clôt le bloc try.
À la suite enfin notez le mot-clé catch (catch = intercepter). catch a le caractère d'une fonction et attend un paramètre e. La variable e est indispensable, étant donné que c'est par elle en fin de compte que vous contrôlez l'état actuel. Le nom de la variable peut être choisi librement (le nom ne doit donc pas être e). À l'intérieur du bloc de fonction de catch(), placé comme d'habitude dans des parenthèses accolades, vous pouvez évaluer au moyen de throw les erreurs définies et y réagir.
Enfin, vous pouvez encore noter le mot-clé finally. Dans le bloc d'instructions qui en dépend, vous pouvez noter d'autres instructions. Ces instructions seront exécutée dans tous les cas, indépendamment du traitement de l'erreur.

Application de l'instruction `try`..`catch` dans l'exemple

Dans la première partie de l'instruction, il est vérifié si la variable x a pour valeur 2 ou bien 3. Selon le résultat, différentes valeurs d'erreurs sont définies avec throw. Si x a pour valeur 2, alors l'"erreur" générée aura pour valeur correct. Si elle a pour valeur 3, alors l'erreur aura pour valeur faux. Les autres valeurs d'erreurs ne sont pas traitées.

Dans le premier passage la variable x dans l'exemple n'existe même pas encore, étant donné qu'elle n'existe qu'après 200 millièmes de seconde. Elle ne peut donc avoir ni la valeur 2 ni la valeur 3. Dans la routine de traitement de l'erreur qui suit catch(e) il est vérifié si l'une des erreurs définies, à savoir correct ou bien faux, est survenue. Dans un premier temps ce n'est visiblement pas le cas. Les instructions qui dépendent des "valeurs d'erreur" correct et faux, ne sont pas exécutées pour cette raison. L'instruction finally est par contre exécutée dans tous les cas. Elle fait en sorte, dans l'exemple, que le paramètre transmis compteur est incrémenté de 1.

Contrôle général

À la fin la fonction teste_x() s'appelle elle-même avec setTimeout() avec 30 millièmes de seconde de délai. Elle conserve ainsi le contrôle sur le déroulement jusqu'à ce qu'un état défini soit atteint. Le paramètre compteur est transmis pour cela à l'aide d'un opérateur pour relier des chaînes de caractères.

Cela devient intéressant quand le moment est atteint où la variable x existe. Dans ce cas, l'un des cas prédéfinis intervient. Étant donné que x a pour valeur 3. c'est l'erreur throw avec la valeur faux qui est générée (cela doit montrer simplement dans l'exemple que throw est conçu pour la création de valeurs, tout à fait caractéristiques d'états d'erreurs fréquentes). Dans le bloc catch(e) qui suit, cela conduit à ce que la fonction affiche_resultat() est appelée. Dans l'exemple, la même valeur est appelée pour les deux valeurs définies pour throw. À cet endroit, vous pouvez cependant noter des instructions complètement différentes. Chacune de ces routines de traitement d'erreur interrompt en même temps la fonction teste_x() avec return, étant donné que x existe alors et que l'"état critique" est terminé.

Sortie du résultat

La fonction affiche_resultat() reçoit comme paramètres transmis les variables compteur et resultat. Dans la variable compteur est sauvegardé le nombre de passages jusqu'à l'existence de la variable x et dans la variable resultat est sauvegardé le résultat du traitement de l'erreur. Avec alert() il est sorti, dans l'exemple, pour le contrôle, combien de passages étaient nécessaires et quel résultat a été atteint.

La sortie montre d'ailleurs très clairement quelles différences existent dans l'interprétation de setTimeout() par les navigateurs. Tandis que l'Explorer Internet MS avait besoin en moyenne lors des tests de cinq passages, Netscape 6.x en nécessitait deux en moyenne et Opera quatre.

Cas d'application

Les vérifications avec la commande try..catch sont par exemple appropriées, quand vous exécutez, comme dans l'exemple, des actions différées dans le temps avec setTimeout() et que vous voulez exécuter des instructions qui en dépendent. La commande est tout aussi appropriée quand vous voulez accéder par exemple à des variables ou des fonctions qui sont notées dans une autre fenêtre cadre, et que le script ne peut pas savoir si le fichier de l'autre fenêtre cadre, dans lequel est noté le script correspondant, a déjà été lu ou pour le moins, s'il en est la page actuellement affichée.