Guide JavaScript 1.5:Instructions

Un article de MDC.

Sommaire 1 Déclaration de blocs 2 Instructions conditionnelles 2.1 L'instruction if...else 2.2 L'instruction switch 3 Boucles 4 L'instruction for 5 L'instruction do...while 6 L'instruction while 7 L'instruction label 8 L'instruction break 9 L'instruction continue 10 Instructions de manipulation d'objets 10.1 L'instruction for...in 10.2 L'instruction for each...in 10.3 L'instruction with 11 Commentaires 12 Instructions de gestion d'exceptions 13 Types d'exceptions 14 L'instruction throw 15 L'instruction try...catch 15.1 Le bloc catch 15.2 Le bloc finally 15.3 Instructions try...catch imbriquées

[modifier] Déclaration de blocs

Un bloc d'instructions sert à grouper des instructions ensemble. Le bloc est délimité par des crochets recourbés :

{
   instruction_1
   instruction_2
   .
   .
   .
   instruction_n
}

Exemple
Les blocs sont souvent utilisés en conjonction avec des instructions de contrôle de flux (par exemple if, for et while).

while (x < 10) {
   x++;
}

Ici, { x++; } est un bloc d'instructions.

Important : JavaScript ne possède pas de visibilité de bloc. Les variables déclarées dans un bloc sont accessibles depuis la fonction ou le script qui l'entoure, et l'effet de leur assignation persiste au-delà du bloc lui-même. Autrement dit, les blocs n'influencent pas la visibilité des variables. Bien qu'il soit syntaxiquement valide de déclarer des blocs « standalone », cela n'a aucun intérêt en JavaScript parce qu'ils n'auront pas l'effet escompté si vous vous attendez à ce qu'ils ressemblent à des blocs similaires en C ou en Java. Par exemple :

var x = 1;
{
   var x = 2;
}
alert(x); // affiche 2

Ce code affiche 2 parce que l'instruction var x au sein du bloc a la même visibilité que l'instruction var x située avant le bloc. En C ou en Java, le code équivalent aurait affiché 1.

[modifier] Instructions conditionnelles

Une instruction conditionnelle est un ensemble de commandes qui sont exécutiées si une condition spécifique est remplie. JavaScript propose deux instructions conditionnelles : if...else et switch.

[modifier] L'instruction if...else

Utilisez if pour exécuter une instruction si une condition logique est vraie. La clause optionnelle else sert à exécuter une autre instruction si la condition est fausse. Une instruction if ressemble à ceci :

if (condition)
   instruction_1
[else
   instruction_2]

condition peut être n'importe quelle expression pouvant être évaluée comme true ou false (vrai ou faux). Si condition est évaluée à true, instruction_1 sera exécutée ; dans le cas contraire, c'est instruction_2 qui sera exécutée. instruction_1 et instruction_2 peuvent être n'importe quelle instruction, y compris d'autres instructions if imbriquées.

Il est également possible d'intégrer les instructions avec else if pour tester plusieurs conditions séquentiellement, comme ceci :

if (condition_1)
   instruction_1
[else if (condition_2)
   instruction_2]
...
[else if (condition_n-1)
   instruction_n-1]
[else
   instruction_n]

Pour exécuter plusieurs instructions à la suite, utilisez un bloc ({ ... }) pour les regrouper. En général, l'utilisation systématique de blocs est une bonne pratique, en particulier lorsque le code utilise plusieurs instructions if imbriquées :

if (condition) {
   instructions_1
} else {
   instructions_2
}

Il est conseillé de ne pas utiliser d'assignations simples dans une expression conditionnelle, parce que l'assignation peut être facilement confondue avec un test d'égalité lors d'un parcours rapide du code. Par exemple, il vaut mieux ne pas utilise le code suivant :

if (x = y) {
   /* faire quelque chose */
}

Si vous désirez réellement faire une assignation dans une expression conditionnelle, il est courant d'ajouter des parenthèses supplémentaires autour de l'assignation. Par exemple :

if ((x = y)) {
   /* faire quelque chose */
}

Ne confondez pas les valeurs booléennes primitives true et false avec les valeurs vraies et fausses de l'objet Boolean. Toute valeur qui n'est pas undefined, null, 0, NaN, ou la chaîne vide (""), et tout objet, y compris un objet Boolean dont la valeur est false, est évalué à true lorsqu'il est évalué dans une instruction conditionnelle. Par exemple :

var b = new Boolean(false);
if (b) // cette condition est évaluée à true

Exemple
Dans l'exemple qui suit, la fonction checkData renvoie true si le nombre de caractères dans un objet Text est de trois ; dans le cas contraire, elle affiche une alerte et renvoie false.

function checkData() {
   if (document.form1.threeChar.value.length == 3) {
      return true;
   } else {
      alert("Entrez exactement trois caractères. " +
         document.form1.threeChar.value + " n'est pas valide.");
      return false;
   }
}

[modifier] L'instruction switch

Une instruction switch permet à un programme d'évaluer une expression et d'essayer faire correspondre sa valeur à un des labels de cas prédéfinis. Si une correspondance est trouvée, le programme exécute l'instruction associée. Une instruction switch ressemble à ceci :

switch (expression) {
   case label_1:
      instructions_1
      [break;]
   case label_2:
      instructions_2
      [break;]
   ...
   default:
      instructions_par_défaut
      [break;]
}

Le programme cherche d'abord parmi les propositions case si l'une d'elles a un label correspondant à la valeur de l'expression, et transfère alors le contrôle à cette clause en exécutant les instructions associées. Si aucun label correspondant n'est trouvé, le programme cherche la clause optionnelle default, et le cas échéant, transfère le contrôle à cette clause en éxécutant les instructions associées. Si aucune clause default n'est trouvée, le programme se poursuit à l'instruction qui suit la fin du bloc switch. Par convention, la clause default est toujours la dernière, mais ce n'est pas obligatoire.

L'instruction optionnelle break associée avec chaque proposition case permet de s'assurer que le programme sortira du bloc switch une fois que l'instruction correspondante a été exécutée et poursuive son exécution à l'instruction qui suit la fin du bloc switch. Si break n'est pas indiqué, le programme continue à l'instruction suivante au sein du bloc switch.

Example
Dans l'exemple suivant, si typefruit est évalué à "Bananes", le programme associe cette valeur avec le cas "Bananes" et exécute l'instruction associée. Lorsque l'instruction break est rencontrée, le programme sort du bloc switch et exécute l'instruction qui suit. Si break n'était pas indiqué, l'instruction pour le cas "Cerises" aurait également été exécutée.

switch (typefruit) {
   case "Oranges":
      document.write("Les oranges sont à 0,59 € le kilo.<br>");
      break;
   case "Pommes":
      document.write("Les pommes sont à 0,32 € le kilo.<br>");
      break;
   case "Bananes":
      document.write("Les bananes sont à 0,48 € le kilo.<br>");
      break;
   case "Cerises":
      document.write("Les cerises sont à 3 € le kilo.<br>");
      break;
   case "Mangues":
   case "Papayes":
      document.write("Les mangues et les papayes sont à 2,79 € le kilo.<br>");
      break;
   default:
      document.write("Désolés, nous n'avons plus de " + fruittype + ".<br>");
}
document.write("Désirez-vous autre chose ?<br>");

[modifier] Boucles

Une boucle est un ensemble de commandes à exécuter de manière répétitive jusqu'à ce qu'une condition spécifique soit remplie. JavaScript propose les instructions de boucle for, do...while et while, ainsi que label (label n'est pas une instruction de boucle, mais est parfois utilisé en conjonction avec celles-ci). Il est également possible d'utiliser les instructions break et continue au sein des boucles.

Il existe une autre instruction, for...in, qui exécute des instructions de manière répétitive, mais est utilisée pour la manipulation d'objets. Consultez pour cela Instructions de manipulation d'objets.

Les instructions de boucles sont :

• L'instruction for
• L'instruction do...while
• L'instruction while
• L'instruction label
• L'instruction break
• L'instruction continue

[modifier] L'instruction for

Une boucle for se répète jusqu'à ce qu'une condition spécifiée soit évaluée à false. La boucle for de JavaScript est similaire à celle qui existe en Java et en C. Une instruction for ressemble à ceci :

for ([instructionInitiale]; [condition]; [instructionIncrémentale])
   instruction

Lorsqu'une boucle for est exécutée, voici ce qui se produit :

1. L'instruction initiale instructionInitiale, si présente, est exécutée. En général, celle-ci initialise un ou plusieurs compteurs de boucle, mais la syntaxe permet d'utiliser une instruction de n'importe quel degré de complexité. On peut également y déclarer des variables.
2. L'expression condition est évaluée. Si la valeur de condition est true, les instructions de la boucle sont exécutées. Si sa valeur est false, la boucle for se termine. Si l'expression condition est totalement absente, la condition est supposée être toujours vraie (true).
3. L'instruction instruction est exécutée. Pour exécuter plusieurs instructions, utilisez une déclaration de bloc ({ ... }) pour les grouper ensemble.
4. L'instruction de mise à jour instructionIncrémentale, si présente, est exécutée, et l'on retourne à l'étape 2.

Exemple
La fonction suivante contient une instruction for qui compte le nombre d'options sélectionnées dans une liste de sélection (un objet Select qui permet des sélections multiples). L'instruction for déclare la variable i et l'initialise à zéro. Elle vérifie que i est inférieur au nombre d'options dans l'objet Select, exécute l'instruction if qui suit, et incrémente i de un après chaque passage dans la boucle.

<script type="text/javascript">//<![CDATA[

function combien(objetSelect) {
   var nbSelection = 0;
   for (var i = 0; i < objetSelect.options.length; i++) {
      if (objetSelect.options[i].selected)
         nbSelection++;
   }
   return nbSelection;
}

//]]></script>
<form name="selectForm">
   <p>
      <strong>Choisissez certains types de musique, puis cliquez sur le bouton :</strong>
      <br/>
      <select name="typesDeMusique" multiple="multiple">
         <option selected="selected">R&B</option>
         <option>Jazz</option>
         <option>Blues</option>
         <option>New Age</option>
         <option>Classique</option>
         <option>Opéra</option>
      </select>
   </p>
   <p>
      <input type="button" value="Combien d'options sont sélectionnées ?"
         onclick="alert ('Nombre d\'options sélectionnées : ' + combien(document.selectForm.typesDeMusique))"/>
   </p>
</form>

[modifier] L'instruction do...while

L'instruction do...while est répétée jusqu'à ce qu'une condition spécifiée soit évaluée à false. Une instruction do...while ressemble à ceci :

do
   instruction
while (condition);

instruction est exécutée une fois avant que la condition soit vérifiée. Pour exécuter plusieurs instructions, utilisez une déclaration de bloc ({ ... }) pour les grouper ensemble. Si condition vaut true, l'instruction est exécutée à nouveau. À la fin de chaque exécution, la condition est vérifiée. Dès qu'elle est évaluée à false, l'exécution s'interromp et l'on passe à l'instruction suivant la boucle do...while.

Exemple
Dans l'exemple suivant, la boucle do est exécutée au moins une fois et continue à être exécutée jusqu'à ce que i ne soit plus inférieur à 5.

do {
   i += 1;
   document.write(i);
} while (i < 5);

[modifier] L'instruction while

Une instruction while est exécutée tant qu'une condition spécifiée est évaluée à true. Une instruction while ressemble à ceci :

while (condition)
   instruction

Si la condition devient fausse (est évaluée à false), l'instruction au sein de la boucle arrête d'être exécutée et le contrôle passe à l'instruction qui suit la boucle.

Le test de la condition est fait avant que l'instruction dans la boucle soit exécutée. Si la condition renvoie true, instruction est exécutée et la condition est vérifiée à nouveau. Si elle renvoie false, la boucle s'arrête et le contrôle passe à l'instruction qui suit la boucle while.

Pour exécuter plusieurs instructions, utilisez une déclaration de bloc ({ ... }) pour les grouper ensemble.

Exemple 1
La boucle while suivante est exécutée tant que n est inférieur à trois :

n = 0;
x = 0;
while (n < 3) {
   n++;
   x += n;
}

À chaque itération, la boucle incrémente n et ajoute cette valeur à x. Par conséquent, x et n prennent les valeurs suivantes :

• Après le premier passage : n = 1 et x = 1
• Après le second passage : n = 2 et x = 3
• Après le troisième passage : n = 3 et x = 6

À la fin du troisième passage, la condition n < 3 n'est plus vraie, et la boucle se termine.

Exemple 2
Évitez les boucles infinies. Assurez-vous que la condition devienne finalement fausse ; autrement, la boucle ne se terminera jamais. Les instructions dans la boucle while suivante seront exécutées indéfiniment parce que la condition ne devient jamais fausse :

while (true) {
   alert("Hello, world");
}

[modifier] L'instruction label

Un label fournit un identifiant à une instruction qui peut servir à la référencer depuis un autre endroit dans le programme. Par exemple, vous pouvez utiliser un label pour identifier une boucle, et utiliser ensuite les instructions break ou continue pour indiquer si le programme doit interrompre la boucle ou poursuivre son exécution.

La syntaxe de l'instruction label ressemble à ceci :

label :
   instruction

La valeur de label peut être n'importe quel identifiant JavaScript qui n'est pas un mot réservé. L'instruction instruction référencée par le label peut être n'importe quelle instruction.

Exemple
Dans cet exemple, le label boucleTest identifie une boucle while.

boucleTest:
while (leTest == true)
   faireQuelqueChose();
}

[modifier] L'instruction break

L'instruction break est utilisée pour mettre fin à une instruction de boucle, un switch ou un label.

• Lorsque break est utilisé sans un label, l'exécution du bloc while, do..while, for ou switch le plus profond dans lequel on se trouve est immédiatement interrompue et le contrôle passe à l'instruction qui suit le bloc.
• Lorsque break est utilisé avec un label, c'est l'instruction portant ce label qui est interrompue.

La syntaxe de l'instruction break ressemble à ceci :

1. break;
2. break label;

La première forme met fin au bloc de boucle ou switch parent le plus profond ; tandis que la seconde forme met fin à l'instruction parente portant le label spécifié.

Exemple
L'exemple suivant parcourt les éléments d'un tableau jusqu'à ce qu'il trouve l'index d'un élément dont la valeur est laValeur :

for (i = 0; i < a.length; i++) {
   if (a[i] == laValeur)
      break;
}

[modifier] L'instruction continue

L'instruction continue peut être utilisée pour relancer une instruction while, do..while, for ou label.

• Lorsque continue est utilisée sans label, l'exécution de l'itération courante du bloc while, do..while ou for le plus profond est interrompue et reprend à l'itération suivante. À la différence de l'instruction break, continue ne met pas tout à fait fin à la boucle. Dans une boucle while, elle retourne à l'évaluation de la condition. Dans une boucle for, elle passe à l'instruction d'incrément.
• Lorsque continue est utilisée avec un label, cela s'applique à l'instruction de boucle identifiée par ce label.

La syntaxe de l'instruction continue ressemble à ceci :

1. continue
2. continue label

Exemple 1
L'exemple suivant montre une boucle while avec une instruction continue qui est exécutée lorsque la valeur de i est trois. Par conséquent, ici n prend successivement les valeurs un, trois, sept et douze.

i = 0;
n = 0;
while (i < 5) {
   i++;
   if (i == 3)
      continue;
   n += i;
}

Exemple 2
Une instruction portant le label verifieietj contient une instruction portant le label verifiej. Si continue est rencontré, le programme interromp l'exécution de l'itération courante de verifiej et commence l'itération suivante. Chaque fois que continue est rencontré, checkj recommence jusqu'à ce que sa condition renvoie false. Lorsque c'est le cas, le reste de l'instruction verifieietj est exécuté, et verifieietj continue à boucler jusqu'à ce que sa condition renvoie false. Lorsque c'est le cas, le programme continue à l'instruction qui suit verifieietj.

Si continue portait un label verifieietj, le programme aurait continué directement à boucler sur l'instruction verifieietj.

verifieietj :
   while (i < 4) {
      document.write(i + "<br/>");
      i += 1;
      verifiej :
         while (j > 4) {
            document.write(j + "<br/>");
            j -= 1;
            if ((j % 2) == 0)
               continue verifiej;
            document.write(j + " est impair.<br/>");
         }
      document.write("i = " + i + "<br/>");
      document.write("j = " + j + "<br/>");
   }

[modifier] Instructions de manipulation d'objets

JavaScript utilise les instructions for...in, for each...in et with pour manipuler les objets.

[modifier] L'instruction for...in

L'instruction for...in parcourt toutes les propriétés d'un objet identifié par la variable spécifiée. Pour chacune de ces propriétés, JavaScript exécute les instructions spécifiées. Une instruction for...in ressemble à ceci :

for (variable in objet) {
   instructions
}

Exemple
La fonction suivante reçoit en paramètre un objet et le nom de cet objet. Elle parcourt ensuite toutes les propriétés de l'objet et renvoie une chaîne listant les noms et valeurs de ces propriétés.

function affiche_props(obj, nom_obj) {
   var resultat = "";
   for (var i in obj) {
      resultat += nom_obj + "." + i + " = " + obj[i] + "<br>"
   }
   resultat += "<hr>";
   return resultat;
}

Pour un objet voiture avec les propriétés marque et modele, le résultat serait :

voiture.marque = Ford;
voiture.modele = Mustang;

Objets Array
Bien qu'il puisse être tentant d'utiliser for...in pour parcourir des objets Array, ce n'est pas forcément une bonne idée. En effet, comme l'instruction for...in parcourt les propriétés personnalisées en plus des éléments du tableau, si l'objet Array a été modifié de manière à lui ajouter des propriétés ou méthodes supplémentaires, l'instruction for...in renverra le nom de ces propriétés personnalisées en plus des indices numériques. Il est donc préférable d'utiliser une boucle for traditionnelle sur l'indice numérique lorsqu'on désire parcourir un tableau.

[modifier] L'instruction for each...in

for each...in est une instruction de boucle introduite dans JavaScript 1.6. Elle est similaire à for...in, mais parcourt les valeurs des propriétés d'un objet plutôt que leur nom.

[modifier] L'instruction with

L'instruction with établit l'objet par défaut pour une série d'instructions. JavaScript cherche parmi tous les noms de variables inconnus de l'ensemble d'instructions pour déterminer s'ils sont des propriétés de cet objet par défaut. Si l'un de ces noms correspond à une propriété, la propriété est utilisée dans l'instruction ; dans le cas contraire, une variable locale ou globale est utilisée.

Une instruction with ressemble à ceci :

with (objet) {
   instructions
}

Exemple
L'instruction with suivante spécifie que l'objet Math est l'objet par défaut. Les instructions qui suivent font référence à la propriété PI et aux méthodes cos et sin, sans spécifier d'objet. JavaScript suppose alors qu'il doit utiliser l'objet Math pour ces références.

var a, x, y;
var r = 10;
with (Math) {
   a = PI * r * r;
   x = r * cos(PI);
   y = r * sin(PI/2);
}

Note : Bien que l'utilisation d'une instruction with puisse rendre votre programme plus concis, son usage impropre peut ralentir votre programme de manière significative. Consultez Référence de JavaScript 1.5 Core:Instructions:with.

[modifier] Commentaires

Les commentaires sont des annotations de l'auteur qui expliquent ce qu'un script fait. Ils sont ignorés par l'interpréteur. JavaScript permet d'utiliser des commentaires du style Java et C++ :

• Les commentaires sur une seule ligne sont précédés d'une double barre oblique (//).
• Les commentaires qui s'étendent sur plusieurs lignes sont précédés de /* et suivis de */ :

Exemple
L'exemple suivant montre deux commentaires :

// Ceci est un commentaire sur une seule ligne.

/* Ceci est un commentaire multiligne. Il peut être de n'importe quelle longueur
et vous pouvez y mettre ce que vous voulez. */

[modifier] Instructions de gestion d'exceptions

Il est possible de provoquer des exceptions à l'aide de l'instruction throw et de les gérer avec les instructions try...catch.

Vous pouvez également utiliser l'instruction try...catch pour capturer des exceptions Java. Consultez Gestion des exceptions Java en JavaScript et Communication de JavaScript à Java pour plus d'informations.

• L'instruction throw
• L'instruction try...catch

[modifier] Types d'exceptions

À peu près n'importe quel objet peut être renvoyé dans une exception en JavaScript. Cependant, tous ces objets ne sont pas égaux. Bien qu'il soit très fréquent de renvoyer des nombres ou des chaînes comme erreurs, il est souvent plus efficace d'utiliser un des types d'exception spécifiquement créés dans ce but :

• Exceptions ECMAScript :
  • Error
  • EvalError
  • RangeError
  • ReferenceError
  • SyntaxError
  • TypeError
  • URIError
• Exceptions DOM :
  • DOMException
  • EventException
  • RangeException
  • ... (?)
• nsIXPCException (XPConnect)

[modifier] L'instruction throw

L'instruction throw s'utilise pour provoquer une exception. Lorsqu'une exception est provoquée, une expression contenant la valeur de cette exception est fournie :

throw expression

Le code suivant provoque différentes exceptions.

throw "Erreur2";   // génère une exception avec une valeur chaîne
throw 42;          // génère une exception avec la valeur 42
throw true;        // génère une exception avec la valeur true

Vous pouvez spécifier un objet comme valeur de l'exception. Ses propriétés peuvent ensuite être référencées dans le bloc catch. L'exemple suivant crée un objet monException de type UserException et l'utilise dans une instruction throw.

// Crée un objet de type UserException
function UserException (message) {
   this.message = message;
   this.name = "UserException";
}
// Crée une instance de l'objet et l'utilise pour générer une exception
monException = new UserException("Valeur trop élevée");
throw monException;

[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.