mozilla
Vos résultats de recherche

    Instructions (Direction du flux d'instructions)

    JavaScript supporte nativement un ensemble d'instructions. Ces instructions permettent de définir les logiques des algorithmes, le flux des informations, etc. Ce chapitre décrit comment fonctionnent les différentes instructions JavaScript..

    Toute expression est une instruction, voir la page Expressions et opérateurs pour plus d'informations sur les expressions.

    En JavaScript, le point-virgule (;) est utilisé afin de séparer des instructions dans le code.

    Voir la Référence JavaScript pour plus de détails sur les différentes instructions décrites dans ce chapitre.

    Les blocs

    Une instruction de bloc permet de regrouper des instructions. Un bloc est délimité par une paire d'accolades :

    {
       instruction_1;
       instruction_2;
       .
       .
       .
       instruction_n;
    }
    

    Exemple
    Les instructions de blocs sont souvent utilisées avec les instructions conditionnelles et itératives telles que if, for, while.

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

    Ici, { x++; } représente le bloc.

    Note importante : En JavaScript, les blocs n'introduisent pas de nouvelles portées. Les variablbes introduites dans le bloc font partie de la portée de la fonction englobante ou du script. Les effets de leur définition persistent en dehors du bloc. Il est tout à fait valide d'utiliser des blocs « seuls » mais ce n'est pas une bonne pratique. En effet, celui qui lit le code et qui ne connaît pas cette particularité de JavaScript pourra penser que c'est un bloc comme en C ou en Java. Par exemple :

    var x = 1;
    {
      var x = 2;
    }
    console.log(x); // affichera 2
    

    Cella affichera 2 car l'instruction var x contenue dans le bloc fait partie de la même portée que l'instruction var x écrite avant le bloc. En C ou en Java, le code équivalent à cet exemple aurait produit 1.

    Note : Pour plus d'informations sur les blocs, voir l'article sur les blocs de la référence JavaScript.

    Les instructions conditionnelles

    Une instruction conditionnelle est un ensemble de commandes qui s'exécutent si une condition donnée est vérifiée. JavaScript possède deux instructions conditionnelles : if...else et switch.

    if...else

    On utilise l'instruction if lorsqu'on souhaite exécuter une instruction si une condition logique est vérifiée (vraie). La clause else est optionnelle et permet de préciser les instructions à exécuter si la condition logique n'est pas vérifiée (l'assertion est fausse). Voici un exemple qui illustre l'utilisation de l'instruction if :

    if (condition) {
      instruction_1;
    } else {
      instruction_2;
    }

    condition peut correspondre à n'importe quelle expression qui est évaluée à true (vrai) ou false (faux). Voir la page sur les booléens pour plus d'informations sur les évaluations qui fournissent les valeurs true ou false. Si la condition vaut true, instruction_1 est exécutée, sinon instruction_2 sera exécutée. instruction_1 et instruction_2 peuvent correspondre à n'importe quelle instruction, y compris d'autres instructions if.

    Si on doit tester différentes conditions les unes à la suite des autres, il est possible d'utiliser else if pour lier les différents tests. On l'utilise de la façon suivante :

    if (condition_1) {
      instruction_1;
    } else if (condition_2) {
      instruction_2;
    } else if (condition_n) {
      instruction_n;
    } else {
      dernière_instruction;
    }

    Afin d'exécuter plusieurs instructions, on peut les regrouper grâce aux blocs ({ ... }) vus précédemment. C'est une bonne pratique que de les utiliser, surtout si on imbrique plusieurs instructions if les unes dans les autres:

    if (condition) {
        instruction_1_exécutée_si_condition_vraie;
        instruction_2_exécutée_si_condition_vraie;
    } else {
        instruction_3_exécutée_si_condition_fausse;
        instruction_4_exécutée_si_condition_fausse;
    }
    
    Attention à ne pas utiliser des intructions d'affectation dans les expressions conditionnelles. On peut, en effet, très facilement confondre l'affectation et le test d'égalité en lisant le code. Voici un exemple de ce qu'il ne faut pas faire :
    if (x = y) {
      /* exécuter des instructions */
    }
    

    Ici, on ne teste pas si x vaut y, on affecte la valeur de y à x ! Si vous devez à tout prix utiliser une affectation dans une expression conditionnelle, une bonne pratique sera d'ajouter des parenthèses en plus autour de l'affectation. Par exemple :

    if ((x = y)) {
      /* exécuter des instructions */
    }
    

    Lors d'un test, les valeurs suivantes seront considérées comme équivalentes à false :

    • false
    • undefined
    • null
    • 0
    • NaN
    • la chaîne de caractères vide ("")

    Les autres valeurs, y compris les objets, seront équivalents à true.

    Attention à ne pas confondre les valeurs booléennes « primitives » true et false avec les valeurs crées grâce à un objet Boolean. Par exemple, on aura :

    var b = new Boolean(false);
    if (b) // cette condition est bien vérifiée !
    

    Exemple
    Dans l'exemple qui suit, la fonction vérifierDonnées renvoie true si une chaîne de caractères mesure trois caractères. Sinon, elle affiche une alerte et renvoie false.

    function checkData(maChaîne) {
      if (maChaîne.length == 3) {
        return true;
      } else {
        alert("Veuillez saisir trois caractères. " +
          maChaîne + " n'est pas valide.");
        return false;
      }
    }
    

    Note : Pour plus d'informations sur cette instruction, voir la page de la référence JavaScript sur if, else et else if.

    L'instruction switch

    L'instruction switch permet à un programme d'évaluer une expression et d'effectuer des instructions en fonction des différents cas de figures correspondants aux différentes valeurs. Si un cas correspond au résultat de l'évaluation, le programme exécute l'instruction associée. Voici un exemple utilisant une instruction switch :

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

    Pour commencer, le programme recherche (dans l'ordre) une clause case dont le label (ou étiquette) correspond à la valeur de l'expression. Si une telle clause est trouvée, le programme exécutera les instructions associées. Si aucune clause case ne correspond, le programme exécutera les instructions de la clause default si elle est présente. Sinon, le programme continuera avec les instructions qui suivent l'instruction switch. Par convention, la clause default est généralement présentée en dernière bien que ce ne soit pas obligatoire.

    L'instruction optionnelle break, éventuellement contenue pour chaque clause case, permet de ne pas exécuter les instructions pour les cas suivants. Si break n'est pas utilié, le programme continuera son exécution avec les autres instructions contenues dans l'instruction switch.

    Exemple
    Dans l'exemple suivant, si fruit vaut "Banane", le programme exécutera les instructions associées. Quand break est rencontré, le programme passe aux instructions décrites après switch. Ici, si break n'était pas présent, les instructions pour le cas "Cerise" aurait également été exécutées.

    switch (fruit) {
       case "Orange":
          document.write("Les oranges sont à 60 centimes le kilo.");
          break;
       case "Pomme":
          document.write("Les pommes sont à 32 centimes le kilo.");
          break;
       case "Banane":
          document.write("Les bananes sont à 48 centimes le kilo.");
          break;
       case "Cerise":
          document.write("Les cerises sont à 3€ le kilo.");
          break;
       case "Mangue":
          document.write("Les mangues sont à 50 centimes le kilo.");
           break;
       default:
          document.write("Désolé, nous n'avons pas de " + fruittype + ".");
    }
    document.write("Souhaitez-vous autre chose ?");

    Note : Pour plus de détails sur cette instruction, voir la page switch de la référence JavaScript.

    Les boucles

    Les boucles sont des instructions qui permettent d'exécuter des instructions de façon répétée jusqu'à ce qu'une certaine condition soit remplie. En JavaScript, les instructions qui permettent de faire des boucles sont for, do while, et while. Au sein de ces boucles, il est possible d'utiliser les instructions break et continue. Les instructions label sont parfois utilisées afin de simuler des boucles.

    for...in est une instruction qui permet d'exécuter du code de façon répétée. Étant donné son lien avec les objets, elle sera vue au paragraphe sur les instructions utilisées avec les objets.

    Les instructions liées aux boucles sont donc :

    L'instruction for

    Une boucle for répète des instructions jusqu'à ce qu'une condition donnée ne soit plus vérifiée. La boucle for JavaScript ressemble beaucoup à celle utilisée en C ou en Java. Une boucle for s'utilise de la façon suivante :

    for ([expressionInitiale]; [condition]; [expressionIncrément])
       instruction
    

    Voici ce qui se passe quand une boucle for s'exécute :

    1. L'expression initiale expressionInitiale est exécutée si elle est présente. Généralement, on utilise cette expression pour initialiser un ou plusieurs compteurs dont on se servira dans la boucle. Il est possible d'utiliser des expressions plus complexes si besoin. Elle peut servir à déclarer des variables.
    2. L'expression condition est évaluée, si elle vaut true, les instructions contenues dans la boucle sont exécutées. Si la valeur de condition est false, la boucle for se termine. Si la condition est absente, elle est considérée comme true.
    3. L'instruction instruction est exécutée. Si on souhaite exécuter plusieurs instructions, on utilisera un bloc d'instructions ({ ... }) afin de les grouper.
    4. Si elle est présente, l'expression de mise à jour expressionIncrément est exécutée. On retourne ensuite à l'étape 2.

    Exemple
    La fonction suivante contient une instruction for qui compte le nombre d'options sélectionnées dans une liste déroulante (ici, un objet Select permettant une sélection multiple). L'instruction for déclare une variable i et l'initialise à zéro. Elle vérifie que i est bien inférieur au nombre d'options et, pour chaque option, effectue un test conditionnel pour savoir si l'option est sélectionnée puis passe à l'option suivante en incrémentant la variable i pour chaque itération.

    <script>
    
    function howMany(selectObject) {
       var numberSelected = 0;
       for (var i = 0; i < selectObject.options.length; i++) {
          if (selectObject.options[i].selected)
             numberSelected++;
       }
       return numberSelected;
    }
    
    </script><script>
    
    function combien(objetSelect) {
       var nbSélectionnés = 0;
       for (var i = 0; i < objetSelect.options.length; i++) {
          if (objetSelect.options[i].selected)
             nbSélectionnés++;
       }
       return nbSélectionnés;
    }
    
    </script>
    
    <form name="selectForm">
       <p>
          <strong>Choisir parmi des types de musique puis cliquer sur le bouton:</strong>
          <br/>
          <select name="typesMusique" 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 ont été choisis ?"
             onclick="alert ("Nombre de sélections : ' + combien(document.selectForm.typesMusique))"/>
       </p>
    </form>

    Note : Pour plus d'informations sur cette instruction, voir la page de la référence JavaScript pour l'instruction for.

    L'instruction do...while

    L'instruction do...while permet de répéter un ensemble d'instructions jusqu'à ce qu'une condition donnée ne soit plus vérifiée. (NdT : littéralement « do...while » signifie en « faire... tant que »). Une instruction do...while s'utilise de la façon suivante :

    do
       instruction
    while (condition);
    

    instruction est exécutée une fois avant que la condition soit vérifiée. Pour utiliser plusieurs instructions à cet endroit, on utilisera une instruction de bloc ({ ... }) pour regrouper différentes instructions. Si la condition est vérifiée, l'instruction est à nouveau exécutée. À la fin de chaque exécution, la condition est vérifiée. Quand la condition n'est plus vérifiée (vaut false ou une valeur équivalente), l'exécution de l'instruction do...while est stoppée et le contrôle passe à l'instruction suivante.

    Exemple
    Dans l'exemple qui suit, la boucle do est exécutée au moins une fois et répétée jusqu'à ce que i ne soit plus inférieur à 5.

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

    Note : Pour plus d'informations sur cette instruction, voir la page de la référence JavaScript pour do...while.

    L'instruction while

    Une instruction while permet d'exécuter une instruction tant qu'une condition donnée est vérifiée. Cette instruction while s'utilise de la façon suivante :

    while (condition)
       instruction
    

    Si la condition n'est pas vérifiée, l'instruction instruction n'est pas exécutée et le contrôle passe directement à l'instruction suivant la boucle.

    Le test de la condition s'effectue avant d'exécuter instruction. Si la condition renvoie true (ou une valeur équivalente), instruction sera exécutée et la condition sera testée à nouveau. Si la condition renvoie false (ou une valeur équivalente), l'exécution s'arrête et le contrôle est passé à l'instruction qui suit while.

    Pour pouvoir utiliser plusieurs instructions dans la boucle, on utilisera une instruction de bloc ({ ... }) afin de les regrouper.

    Exemple 1
    La boucle while qui suit permet d'effectuer des itérations tant que n est inférieur à 3 :

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

    À chaque itération, la boucle incrémente n et ajoute la valeur de n à x. x et n prendront ainsi les valeurs suivantes :

    • Après la première itération : n = 1 et x = 1
    • Après la deuxième itération : n = 2 et x = 3
    • Après la troisième itération : n = 3 et x = 6

    Une fois la troisième itération effectuée, la condition n < 3 n'est plus vérifiée, par conséquent, la boucle se termine.

    Exemple 2
    Attention à éviter les boucles infinies. Il faut bien s'assurer que la condition utilisée dans la boucle ne soit plus vérifiée à un moment donné. Si la condition est toujours vérifiée, la boucle se répétera sans jamais s'arrêter. Dans l'exemple qui suit, les instructions contenues dans la boucle while s'exécutent sans discontinuer car la condition est toujours vérifiée :

    while (true) {
       alert("Coucou monde !");
    }

    Note : Pour plus d'informations sur cette instruction, voir la page de la référence JavaScript sur while.

    L'instruction label

    Un label (ou étiquette) permet de fournir un identifiant pour une instruction afin d'y faire référence depuis un autre endroit dans le programme. On peut ainsi identifier une boucle grâce à un label puis utiliser les instructions break ou continue pour indiquer si le programme doit interrompre ou poursuivre l'exécution de cette boucle.

    On utilise un label de la façon suivante :

    label :
       instruction
    

    La valeur de label peut être n'importe quel identifiant JavaScript valide (et ne doit pas être un mot réservé pour le langage). L'instruction peut être n'importe quelle instruction JavaScript valide (y compris un bloc).

    Exemple
    Dans cet exemple, on utilise un label memoBoucle pour identifier une boucle while.

    memoBoucle:
    while (memo == true) {
       faireQQC();
    }

    Note : Pour plus de détails sur cette instruction, voir la page de la référence JavaScript pour label.

    L'instruction break

    L'instruction break est utilisée pour finir l'exécution d'une boucle, d'une instruction switch, ou avec un label.

    • Lorsque break est utilisé sans label, il provoque la fin de l'instruction while, do-while, for, ou switch dans laquelle il est inscrit (on finit l'instruction la plus imbriquée), le contrôle est ensuite passé à l'instruction suivante.
    • Lorsque break est utilisé avec un label, il provoque la fin de l'instruction correspondante.

    La syntaxe de cette instruction possède donc deux formes :

    1. break;
    2. break label;

    La première forme permet d'interrompre la boucle la plus imbriquée (ou le switch) dans laquelle on se trouve. La seconde forme interrompt l'exécution d'une instruction identifiée par un label.

    Exemple 1
    Dans l'exemple qui suit, on itère sur un tableau grâce à une boucle jusqu'à trouver un élément dont la valeur est valeurTest :

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

    Exemple 2

    Ici, on utilise break des deux façons : avec une instruction représentée par un label et sans.

    var x = 0;
    var z = 0
    labelAnnuleBoucle: while (true) {
        console.log("Boucle externe : " + x);
        x += 1;
        z = 1;
        while (true) {
            console.log("Boucle interne : " + z);
            z += 1;
            if (z === 10 && x === 10) {
                break labelAnnuleBoucle;
            } else if (z === 10) {
                break;
            }
        }
    }
    

    Note : Pour plus d'informations sur cette instruction, voir la page de la référence JavaScript sur break.

    L'instruction continue

    L'instruction continue permet de reprendre une boucle while, do-while, for, ou une instruction label.

    • Lorsque continue est utilisé sans label, l'itération courante de la boucle (celle la plus imbriquée) est terminée et la boucle passe à l'exécution de la prochaine itération. À la différence de l'instruction break, continue ne stoppe pas entièrement l'exécution de la boucle. Si elle est utilisée dans une boucle while, l'itération reprend au niveau de la condition d'arrêt. Dans une boucle for, l'itération reprend au niveau de l'expression d'incrément pour la boucle.
    • Lorsque continue est utilisé avec un label, il est appliqué à l'instruction de boucle correspondante.

    L'instruction continue s'utilise donc de la façon suivante :

    1. continue;
    2. continue label;

    Exemple 1
    Dans l'exemple qui suit, on utilise une boucle while avec une instruction continue qui est exécutée lorsque i vaut 3. Ici, n prendra donc les valeurs 1, 3, 7 et 12.

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

    Exemple 2
    Une instruction identifiée par le label vérifierIetJ contient une instruction identifiée par le label vérifierJ. Si on atteint continue, le programme stoppe l'itération en cours pour vérifierJ et reprend avec l'itération suivante jusqu'à ce que la condition d'arrêt ne soit plus vérifiée false. Quand la condition d'arrêt de la boucle interne n'est plus vérifiée, on poursuit ce qui reste de l'instruction vérifierIetJ qui est répétée jusqu'à ce que la condition d'arrêt soit atteinte (celle de la boucle while externe). Une fois que la boucle externe est terminée, le contrôle est passé à l'instruction qui suit celle identifiée par vérifierIetJ.

    vérifierIetJ :
       while (i < 4) {
          document.write(i + "
    ");
          i += 1;
          vérifierJ :
             while (j > 4) {
                document.write(j + "
    ");
                j -= 1;
                if ((j % 2) == 0)
                   continue vérifierJ;
                document.write(j + " est impair.
    ");
             }
          document.write("i = " + i + "
    ");
          document.write("j = " + j + "
    ");
       }

    Note : Pour plus d'informations sur cette instruction, voir la page de la référence JavaScript sur continue.

    Les instructions utilisées avec les objets

    JavaScript permet d'utiliser les instructions for...in, for each...in, et with pour manipuler les objets.

    L'instruction for...in

    L'instruction for...in permet d'itérer sur l'ensemble des propriétés d'un objet. Pour chaque propriété, JavaScript exécutera l'instruction indiquée. Cette instruction s'utilise de la façon suivante :

    for (variable in objet) {
       instruction
    }
    

    Exemple
    La fonction suivante prend comme argument un objet et le nom de cet objet. Elle parcourt ensuite les propriétés de l'objet et renvoie une chaîne de caractères qui liste les propriétés avec leurs noms et leurs valeurs respectives  :

    function afficherProps(obj, nomObj) {
       var result = "";
       for (var i in obj) {
          result += nomObj + "." + i + " = " + obj[i] + "\n";
       }
       result += "\n";
       return result; 
    }
    

    Pour un objet voiture dont les propriétés sont fabricant et modèle, result serait :

    voiture.fabricant = Ford
    voiture.modèle = Mustang
    

    Les tableaux (arrays) et for...in

    Bien qu'il soit tentant d'utiliser cette instruction pour parcourir les éléments d'un objet Array , cela peut avoir des comportements inattendus. En effet, for...in permet de parcourir les propriétés définies par l'utilisateur ainsi que les éléments de tableau. Ainsi, si on modifie un objet Array en lui ajoutant des propriétés et/ou des méthodes, la boucle for...in renverra le nom de ces nouvelles propriétés en plus des indices des éléments du tableau. C'est pourquoi, il est préférable d'utiliser une boucle for avec les indices du tableau pour parcourir ses éléments.

    Note : Pour plus d'informations sur cette instruction, voir la page de la référence JavaScript sur for...in.

    L'instruction for each...in

    for each...in est une instruction introduite avec JavaScript 1.6. Elle est semblable à for...in (voir ci-avant) mais permet d'itérer sur les valeurs des propriétés de l'objet et non sur leurs noms.

    var somme = 0;
    var obj = {prop1: 5, prop2: 13, prop3: 8};
    for each (var valeurProp in obj) {
      somme += valeurProp;
    }
    console.log(somme); // affiche "26" qui correspond à 5+13+8

    Note : Pour plus d'informations sur cette instruction, voir la page de la référence JavaScript sur for each...in.

    Les commentaires

    Les commentaires peuvent être utilisés par les auteurs du script pour l'annoter et expliquer son fonctionnement. L'interpréteur JavaScript ignorera les commentaires dans le code. JavaScript permet d'utiliser des commentaires semblables à ceux présents en Java et en C++ :

    • Les commentaires sur une seule ligne sont précédés par deux barres obliques (//).
    • Les commentaires sur plusieurs lignes sont précédés de /* et suivi de */ .

    Exemple
    L'exemple qui suit utilise les deux styles de commentaires :

    // Un commentaire sur une seule ligne.
    
    /* Un commentaire qui s'étale sur plusieurs lignes
    il peut être aussi long qu'on le souhaite. */

    Les instructions utilisées pour les exceptions

    JavaScript permet d'utiliser des exceptions pour indiquer des erreurs. On peut signaler une exception en utilisant l'instruction throw. Afin de gérer le cas où on reçoit une instruction, on utilisera une instruction try...catch.

    Les types d'exception

    En JavaScript, n'importe quel objet peut être signalé comme une exception. Cependant, afin de respecter certaines conventions et de bénéficier de certaines informations, on pourra utiliser les types destinés à cet effet :

    L'instruction throw

    L'instruction throw est utilisée afin de signaler (throw en anglais) une exception. Lorsqu'on signale une exception, on définit une expression qui contient la valeur à renvoyer pour l'exception :

    throw expression;
    

    Il est possible d'utiliser n'importe quelle expression, sans restriction de type. Le fragment de code qui suit illustre les différentes possibilités :

    throw "Erreur2";  //type String
    throw 42;         //type Number
    throw true;       //type Boolean
    throw {toString: function() { return "je suis un objet !"; } };
    
    Note : Il est possible de renvoyer un objet quand on signale une exception. Les propriétés de cet objet pourront être utilisées dans le bloc catch décrit ci-après. Dans l'exemple suivant, on définit un objet monException du type ExceptionUtilisateur, on utilise cet objet dans l'instruction throw.
    // On crée le constructeur pour cet objet
    function ExceptionUtilisateur(message){
      this.message=message;
      this.name="ExceptionUtilisateur";
    }
    
    // On surcharge la méthode toString pour afficher 
    // un message plus explicite (par exemple dans la console)
    ExceptionUtilisateur.prototype.toString = function (){
      return this.name + ': "' + this.message + '"';
    }
    
    // On crée une instance pour ce type d'objet 
    // et on renvoie une exception avec cette instance
    throw new ExceptionUtilisateur("La valeur fournie est trop élevée.");

    Note : Pour plus d'informations sur cette instruction, voir la page de la référence JavaScript sur throw.

    L'instruction try...catch

    L'instruction try...catch permet de définir un bloc d'instructions qu'on essaye (try en anglais) d'exécuter, ainsi qu'une ou plusieurs instructions à utiliser en cas d'erreur lorsqu'une exception se produit. Si une exception est signalée, l'instruction try...catch permettra de l' « attraper » (catch en anglais) et de définir ce qui se passe dans ce cas.

    L'instruction try...catch se compose d'un bloc try qui contient une ou plusieurs instructions et de zéro ou plusieurs blocs catch qui contiennent les instructions à exécuter lorsqu'une exception se produit dans le bloc try. Autrement dit, dans la plupart des cas pour le programme, on veut que les instructions du bloc try se déroulent normalement et en cas de problème, on passe le contrôle au bloc catch. Si une instruction contenue dans le bloc try renvoie une exception, le contrôle sera immédiatement transféré au bloc catch. Si aucune exception n'est signalée au sein du bloc try, le bloc catch ne sera pas utilisé. Cette instruction peut comporter un bloc finally qui s'exécute après les blocs try et catch mais avant les instructions suivant l'instruction try...catch.

    Dans l'exemple qui suit, on utilise une instruction try...catch. On définit une fonction qui prend un nombre et renvoie le nom du mois correspondant à ce nombre. Si la valeur fournie n'est pas comprise entre 1 et 12, on signale une exception avec la valeur "NuméroMoisInvalide". Lorsque cette exception est gérée dans le bloc catch, la variable nomMois recevra la valeur "inconnu".

    function getNomMois(numMois) {
        numMois = numMois-1; // On décale de 1 car les indices du tableaux commencent à 0
        var mois =new Array("Janvier","Février","Mars","Avril","Mai","Juin","Juillet",
              "Août","Septembre","Octobre","Novembre","Décembre");
        if (mois[numMois] != null) {
           return mois[numMois]
        } else {
           throw "NuméroMoisInvalide"  //Ici on utilise l'instruction throw
        }
    }
    
    try {// les instructions à essayer si tout se passe bien
        nomMois = getNomMois(maVarMois) // La fonction peut renvoyer une exception
    }
    catch (e) {
        nomMois = "inconnu"
        gestionErreurLog(e) // on gère l'erreur
    }
    

    Le bloc catch

    Un bloc catch peut être utilisé afin de gérer les exceptions pouvant être générées par les instructions du bloc try.

    catch (ident) {
      statements
    }
    

    Le bloc catch définit un identifiant (ident dans le fragment de code précédent) qui contiendra la valeur passée par l'instruction throw. Cet identifiant peut être utilisé afin de récupérer des informations sur l'exception qui a été signalée. Le moteur JavaScript crée cet identifiant lorsque le contrôle passe au bloc catch. L'identifiant ne « vit » qu'à l'intérieur du bloc catch et une fois que l'exécution du bloc catch est terminée, l'identifiant n'est plus disponible.

    Dans l'exemple suivant, le code renvoie une exception. Lorsque celle-ci est signalée, le contrôle passe au bloc catch.

    try {
       throw "monException" // on génère une exception
    }
    catch (e) {
    // les instructions utilisées pour gérer les exceptions
       enregistrerErreurs(e) // on passe l'objet représentant l'exception à une fonction utilisée pour gérer les erreurs
    }
    

    Note : Pour plus d'informations sur cette instruction, voir la page de la référence JavaScript sur try...catch.

    Le bloc finally

    Le bloc finally contient les instructions à exécuter après les blocs try et catch mais avant l'instruction suivant le try...catch. Le bloc finally est exécuté dans tous les cas, qu'il y ait une exception de produite ou non. Si une exception est signalée et qu'il n'y a pas de bloc catch pour la gérer, les instructions du bloc finally seront tout de même exécutées.

    Le bloc finally peut être utilisé afin de finir proprement l'exécution malgré une exception. On peut, par exemple, devoir libérer une ressource, ou fermer un flux, etc. Dans l'exemple suivant, on écrit dans un fichier, si une exception se produit lors de l'écriture, on utilisera le bloc finally afin de bien fermer le flux vers le fichier avant la fin du script.

    ouvrirFichier();
    try {
        écrireFichier(données); //Une erreur peut se produire
    }catch(e){
        gérerException(e); // On gère le cas où on a une exception
    }finally {
        fermerFichier(); // On n'oublie jamais de fermer le flux.
    }
    

    Si le bloc finally renvoie une valeur, cette valeur sera considérée comme la valeur de retour pour tout l'ensemble try-catch-finally, quel que soient les instructions return éventuellement utilisées dans les blocs try et catch :

    function f() {
        try {
            console.log(0);
            throw "bug";
        } catch(e) {
            console.log(1);
            return true; // Cette instruction est bloquée jusqu'à la fin du bloc finally
            console.log(2); // Ne pourra jamais être exécuté
        } finally {
            console.log(3);
            return false; // On surcharge l'instruction "return" précédente
            console.log(4); // Ne pourra jamais être exécuté
        }
        // "return false" is executed now
        
        console.log(5); // Ne pourra jamais être exécuté
    }
    f(); // affiche 0, 1, 3 puis renvoie false
    

    Imbriquer des instructions try...catch

    Il est possible d'imbriquer plusieurs instructions try...catch. Si une instruction try...catch ne comportant pas de bloc catch est contenue dans une autre instruction try...catch, on utilisera le bloc catch de celle-ci si jamais il y a une exception.

    Utiliser les objets Error

    En fonction du type d'erreur qui est créée, on pourra utiliser les propriétés name et message afin d'obtenir plus d'informations. Généralement on a name qui fournit le type d'erreur rencontrée (ex : DOMException ou Error). La propriété message, quant à elle fournit un message descriptif de l'erreur (qu'on utilisera généralement lorsqu'on voudra convertir/afficher le texte correspondant à une erreur.

    Si vous construisez des erreurs, vous pouvez utiliser le constructeur Error afin de disposer de ces propriétés. Ainsi, on pourra avoir :

    function causerErreurs() {
       if (toutEstSourceDErreurs()) {
          throw (new Error('mon message'));
       }
       else {
          générerUneAutreErreur();
       }
    }
    ....
    try {
       causerErreurs();
    }
    catch (e) {
       console.log(e.name);// affiche 'Error'
       console.log(e.message); // affiche 'mon message' ou un message d'erreur JavaScript
    }

    Suivant » « Précédent

    Étiquettes et contributeurs liés au document

    Contributors to this page: teoli, SphinxKnight
    Dernière mise à jour par : SphinxKnight,
    Masquer la barre latérale