Passer au contenu
Sujets
  • 1 Commencer
    1.1

    Votre premier programme

    Un programme est une liste d'instructions destinées à l'ordinateur. En JavaScript, chaque instruction est une instruction (statement), et l'ordinateur exécute ces instructions de haut en bas.

    console.log(...) affiche une valeur dans la console, la zone de texte située sous le code :

    console.log("Hello, world!");
    console.log(7 * 6);   // 42
    
    • Le texte va entre guillemets : "Hello" ou 'Hello'. Les nombres ne s'y placent pas.
    • Terminez chaque instruction par un point-virgule ;. JavaScript peut souvent deviner où il manque, mais l'écrire rend le code plus clair.
    • JavaScript est sensible à la casse : console.log fonctionne, Console.Log ne fonctionne pas.

    console.log peut afficher plusieurs valeurs à la fois. Il insère un espace entre elles :

    console.log("Total:", 3 + 4);   // Total: 7
    console.log(1, 2, 3);           // 1 2 3
    
    1.2

    Commentaires et style de code

    Un commentaire est une note destinée aux humains. JavaScript l'ignore lors de l'exécution du programme.

    // A one-line comment starts with two slashes.
    console.log("This line runs");   // a comment can follow code
    
    /* A block comment
       can cover several lines. */
    console.log("So does this one");
    

    Un bon style rend le code facile à lire :

    • Indentez les lignes situées à l'intérieur de { } de deux ou quatre espaces, et appliquez toujours la même méthode.
    • Donnez aux variables des noms explicites indiquant ce qu'elles contiennent : total, et non t.
    • Les noms en JavaScript utilisent le camelCase : firstName, scoreTotal.
    // Work out the area of a rectangle
    const width = 4;
    const height = 3;
    console.log(width * height);   // 12
    

    Erreurs courantes

    • Le texte nécessite des guillemets correspondants : "Hi' est une erreur.
    • console.log est tout en minuscules : Console.log et console.Log sont des erreurs.
    • Tout ce qui suit // sur une ligne est ignoré, donc // console.log(x) n'affiche rien.
  • 2 Valeurs, variables et types
    2.1

    let et const

    Une variable est une boîte nommée contenant une valeur. Créez-en une avec let ou const, puis utilisez son nom :

    let score = 10;
    score = score + 5;      // let: the value can change
    console.log(score);     // 15
    
    const name = "Mei";     // const: the name cannot be reassigned
    console.log(name);      // Mei
    
    • = signifie assigner : calculez la partie droite, puis stockez-la dans la boîte de gauche.
    • Utilisez const par défaut. N'utilisez let que si la valeur doit changer ultérieurement.
    • Réaffecter une variable const est une erreur : name = "Tom" n'est pas autorisé. Un objet ou un tableau constant peut néanmoins voir son contenu modifié.
    2.2

    Nombres et mathématiques

    Ces exemples utilisent le type nombre pour les valeurs entières et décimales. BigInt est un type entier distinct. Les opérateurs arithmétiques sont :

    Opérateur Signification Exemple Résultat
    + - addition, soustraction 7 - 2 5
    * / multiplication, division 7 / 2 3.5
    % reste 7 % 2 1
    ** puissance 2 ** 3 8
    console.log(7 / 2);              // 3.5
    console.log(Math.floor(7 / 2));  // 3   (whole-number division)
    console.log(7 % 2);              // 1   (odd numbers leave 1)
    console.log(2 + 3 * 4);          // 14  (* before +)
    console.log((2 + 3) * 4);        // 20
    

    Math contient des fonctions utiles :

    console.log(Math.round(2.5));    // 3
    console.log(Math.max(4, 9, 2));  // 9
    console.log(Math.sqrt(49));      // 7
    
    • Math.random() génère un nombre aléatoire de 0 jusqu'à (sans inclure) 1. Math.floor(Math.random() * 6) + 1 simule un lancer de dé entre 1 et 6.
    • Les décimaux sont stockés en binaire, donc 0.1 + 0.2 affiche 0.30000000000000004. Arrondissez un résultat avant de l'afficher : (0.1 + 0.2).toFixed(2) vaut "0.30".
    2.3

    Types et conversion

    Chaque valeur a un type. typeof indique lequel :

    console.log(typeof 42);         // number
    console.log(typeof "42");       // string
    console.log(typeof true);       // boolean
    console.log(typeof undefined);  // undefined
    
    • Une variable créée avec let x; et sans valeur est undefined.
    • null signifie « aucune valeur » et est définie intentionnellement.

    + avec une chaîne concatène au lieu d'additionner, convertissez donc d'abord le texte en nombre :

    console.log("5" + 1);           // 51  (joined)
    console.log(Number("5") + 1);   // 6   (added)
    console.log(parseInt("12px"));  // 12  (reads the number at the start)
    console.log(String(9) + "!");   // 9!
    
    • Un texte qui n'est pas un nombre donne NaN (« pas un nombre ») : Number("abc") est NaN.
    • -, * et / convertissent automatiquement le texte en nombre ("6" * 2 est 12), mais ne vous y fiez pas : effectuez la conversion intentionnellement.

    Erreurs courantes

    • = affecte ; il ne compare pas. La comparaison utilise === (chapitre 4).
    • "5" + 1 est "51". Convertissez l'entrée avec Number(...) avant d'effectuer des calculs dessus.
    • Math.round(2.5) est 3, mais Math.round(-2.5) est -2 : il arrondit les demi-valeurs vers le haut, vers le nombre supérieur.
  • 3 Chaînes de Caractères
    3.1

    Caractères et longueur

    Une chaîne est du texte entre guillemets. Avec des lettres simples, chaque caractère occupe une position unique, son index ; le premier index est 0. JavaScript compte les unités de code UTF-16 : un emoji peut occuper deux positions.

    const word = "Script";
    console.log(word.length);     // 6
    console.log(word[0]);         // S
    console.log(word[2]);         // r
    console.log(word.at(-1));     // t  (counts back from the end)
    console.log(word[word.length - 1]);   // t
    
    • Le dernier index est length - 1. word[6] est undefined, pas une erreur.
    • Les chaînes de caractères sont immuables : word[0] = "s" ne peut pas modifier la chaîne et provoque un TypeError en mode strict. Créez plutôt une nouvelle chaîne.

    Joignez des chaînes avec +, ce qu'on appelle la concaténation :

    const first = "Ada";
    const last = "Lovelace";
    console.log(first + " " + last);   // Ada Lovelace
    
    3.2

    Méthodes String

    Une méthode est une fonction qui appartient à une valeur. Appelez-la avec un point. Une méthode de chaîne renvoie une nouvelle valeur et laisse l'originale inchangée.

    const city = "  Hong Kong ";
    console.log(city.trim());                 // Hong Kong
    console.log(city.trim().toUpperCase());   // HONG KONG
    console.log(city.length);                 // 12  (the spaces are still there)
    
    Méthode Signification Exemple Résultat
    .toUpperCase() / .toLowerCase() changer la casse "Hi".toLowerCase() "hi"
    .trim() supprime les espaces aux deux extrémités " hi ".trim() "hi"
    .includes(t) contient-il t ? "cat".includes("a") true
    .indexOf(t) première position de t, ou -1 "cat".indexOf("t") 2
    .slice(a, b) caractères de a jusqu'à (sans inclure) b "Script".slice(0, 3) "Scr"
    .split(sep) découpe en tableau "a,b,c".split(",") ["a","b","c"]
    .replace(a, b) remplace le premier a par b "cat".replace("c", "b") "bat"
    const email = "[email protected]";
    const at = email.indexOf("@");
    console.log(email.slice(0, at));          // mei
    console.log(email.slice(at + 1));         // school.org
    console.log(email.split("@"));            // ["mei","school.org"]
    
    3.3

    Littéraux de modèle

    Un littéral de modèle est une chaîne écrite entre des accents graves (sur la plupart des claviers, la touche à gauche de 1). Placez toute expression dans ${ } et sa valeur sera insérée dans le texte :

    const name = "Mei";
    const age = 17;
    console.log(`${name} is ${age} years old.`);   // Mei is 17 years old.
    console.log(`Next year: ${age + 1}`);          // Next year: 18
    
    • Les accents graves peuvent aussi contenir plusieurs lignes de texte.
    • C'est plus lisible que de nombreux signes + : comparez "Hi " + name + "!" avec `Hi ${name}!`.
    const price = 4.5;
    console.log(`Two cost $${(price * 2).toFixed(2)}`);   // Two cost $9.00
    

    Erreurs courantes

    • ${ } ne fonctionne que dans des accents graves. Dans "Hi ${name}", le texte s'affiche exactement tel qu'il est tapé.
    • Les méthodes ne modifient pas la chaîne : appeler city.trim() sur une ligne seule ne fait rien. Stockez le résultat : const clean = city.trim();.
    • slice(a, b) s'arrête avant b, tout comme le dernier index est length - 1.
  • 4 Décisions
    4.1

    Booléens & comparaisons

    Un booléen est soit true soit false. Une comparaison donne un booléen :

    Opérateur Signification Exemple Résultat
    === égal (même valeur et même type) 5 === 5 true
    !== ne pas être égal à 5 !== 3 true
    < > inférieur, supérieur 2 > 7 false
    <= >= au plus, au moins 7 >= 7 true
    console.log(5 === 5);     // true
    console.log(5 === "5");   // false  (a number is not a string)
    console.log(5 == "5");    // true   (== converts first: avoid it)
    
    • Utilisez toujours === et !==. L'ancien == convertit d'abord les types et donne des résultats inattendus.

    Pour les conditions booléennes, utilisez les opérateurs logiques ci-dessous. Pour d'autres valeurs, && et || retournent l'un de leurs opérandes ; ils ne retournent pas toujours un booléen :

    • && (et) : vrai uniquement si les deux côtés sont vrais.
    • || (ou) : vrai si au moins un côté est vrai.
    • ! (non) : transforme true en false et vice versa.
    const age = 15;
    console.log(age >= 13 && age <= 19);   // true   (a teenager)
    console.log(age < 5 || age > 65);      // false
    console.log(!(age > 18));              // true
    
    4.2

    if / else if / else

    Une instruction if exécute un bloc de code lorsque sa condition est truthy (traitée comme vraie). Avec des conditions booléennes, cela signifie que la valeur est true. else if teste une autre condition ; else attrape tout ce qui reste :

    const mark = 72;
    if (mark >= 80) {
      console.log("A");
    } else if (mark >= 60) {
      console.log("B");
    } else {
      console.log("C");
    }
    // prints B
    
    • JavaScript vérifie les conditions de haut en bas et exécute uniquement le premier branchement vrai.
    • La condition va entre parenthesses ; le code à exécuter va entre accolades { }.

    L'ordre compte donc. Placez le test le plus strict en premier :

    const temp = 35;
    if (temp > 30) {
      console.log("hot");
    } else if (temp > 20) {
      console.log("warm");   // skipped: the first branch already ran
    }
    // prints hot
    
    4.3

    interrupteur

    Un switch compare une valeur contre plusieurs cas fixes. Il est plus propre qu'une longue chaîne else if lorsque chaque test est « est-il égal à … ? » :

    const day = "Sat";
    switch (day) {
      case "Sat":
      case "Sun":
        console.log("weekend");
        break;
      case "Fri":
        console.log("nearly there");
        break;
      default:
        console.log("school day");
    }
    // prints weekend
    
    • switch compare avec ===, donc case 1: ne correspond pas à la chaîne "1".
    • break termine le switch. Sans lui, le code passe au cas suivant.
    • default s'exécute quand aucun cas ne correspond, comme un dernier else.
    • Deux cas sans code entre eux partagent le même code, comme "Sat" et "Sun" le font ici.

    Erreurs courantes

    • if (x = 5) affecte au lieu de comparer, et le test est alors toujours vrai. Écrivez if (x === 5).
    • if (age > 13 && < 19) est une erreur : répéter la variable, age > 13 && age < 19.
    • Un break manquant dans un switch exécute aussi le cas suivant.
  • 5 Boucles
    5.1

    Boucles for

    Les trois parties d'une boucle for et l'ordre dans lequel elles s'exécutent

    Une boucle répète un bloc de code. Une boucle for est idéale lorsque vous connaissez le nombre d'itérations. Ses accolades contiennent trois parties séparées par des points-virgules :

    for (let i = 1; i <= 3; i++) {
      console.log(i);
    }
    // 1
    // 2
    // 3
    
    1. début : let i = 1 s'exécute une seule fois, avant la boucle.
    2. condition : i <= 3 est vérifiée avant chaque passage ; la boucle s'arrête quand elle devient fausse.
    3. incrémentation : i++ (ajout de 1 à i) s'exécute après chaque passage.

    Chaque passage dans la boucle constitue une itération. Modifiez l'étape pour compter selon d'autres méthodes :

    let line = "";
    for (let i = 10; i > 0; i -= 3) {
      line += i + " ";
    }
    console.log(line);   // 10 7 4 1
    

    Le motif accumulateur crée une variable avant la boucle et la met à jour à chaque passage :

    let total = 0;
    for (let n = 1; n <= 5; n++) {
      total += n;          // the same as total = total + n
    }
    console.log(total);    // 15
    
    5.2

    Boucles while

    Une boucle while se répète tant que sa condition est vraie. Utilisez-la lorsque vous ne pouvez pas prévoir à l'avance le nombre de passages nécessaires :

    let money = 100;
    let years = 0;
    while (money < 200) {
      money = money * 1.1;   // 10% interest each year
      years++;
    }
    console.log(years);      // 8
    
    • La condition est vérifiée avant chaque passage, donc le corps peut ne jamais s'exécuter.
    • Si la condition reste vraie et qu'aucun break ou autre sortie n'est atteint, vous obtenez une boucle infinie. (Appuyez sur Arrêter si cela se produit.)
    5.3

    for...of, break et continue

    for...of parcourt chaque élément d'un tableau (ou chaque caractère d'une chaîne) successivement, sans gestion d'index :

    const fruits = ["apple", "kiwi", "plum"];
    for (const fruit of fruits) {
      console.log(fruit.toUpperCase());
    }
    // APPLE
    // KIWI
    // PLUM
    

    break sort immédiatement d'une boucle ; continue saute le reste du passage actuel et passe au suivant :

    const marks = [55, 80, -1, 90];
    let sum = 0;
    for (const m of marks) {
      if (m < 0) {
        break;            // -1 means "end of the data"
      }
      if (m < 60) {
        continue;         // skip a fail, keep looping
      }
      sum += m;
    }
    console.log(sum);     // 80
    

    Erreurs courantes

    • Erreur hors limites : i < 3 s'exécute pour 0, 1, 2 ; i <= 3 s'exécute une fois de plus. Comptez les passages.
    • Initialiser le total à l'intérieur de la boucle : let total = 0; doit se trouver avant la boucle, sinon il est réinitialisé à chaque passage.
    • Une boucle while tourne indéfiniment si sa condition reste vraie et qu'aucune sortie n'est atteinte.
  • 6 Fonctions
    6.1

    Paramètres & retour

    Une fonction est un morceau de code réutilisable. Une déclaration de fonction lui donne un nom, que vous pouvez utiliser pour l'appeler :

    function greet(name) {
      return `Hello, ${name}!`;
    }
    
    console.log(greet("Mei"));   // Hello, Mei!
    console.log(greet("Tom"));   // Hello, Tom!
    
    • name est un paramètre : une variable qui reçoit une valeur lors de l'appel de la fonction.
    • "Mei" est l'argument : la valeur réelle transmise.
    • return renvoie une valeur à l'appelant et termine la fonction immédiatement.

    Une fonction régulière qui atteint sa fin sans retourner de valeur renvoie undefined. Ainsi, retournez la réponse, et laissez l'appelant décider s'il doit l'afficher :

    function area(width, height) {
      return width * height;
    }
    
    const a = area(4, 3);
    console.log(a + 1);          // 13  (a returned value can be used again)
    
    6.2

    Fonctions fléchées

    Une fléchée est une écriture plus courte pour une fonction. Stockez-la dans une const :

    const square = (n) => n * n;
    const add = (a, b) => a + b;
    
    console.log(square(5));      // 25
    console.log(add(2, 3));      // 5
    
    • Avec une seule expression après =>, sa valeur est retournée sans écrire return.
    • Avec des accolades, vous avez encore besoin de return :
    const grade = (mark) => {
      if (mark >= 50) {
        return "pass";
      }
      return "fail";
    };
    console.log(grade(64));      // pass
    

    Les fléchées sont souvent passées à d'autres fonctions, comme vous le verrez avec map et filter dans le sujet 7.

    6.3

    Portée

    La portée d'une variable est la partie du code qui peut la voir. Une variable créée avec let ou const à l'intérieur de { } est accessible dans ce bloc et ses portées imbriquées. Une fonction imbriquée peut conserver l'accès après que l'appel externe ait retourné :

    const level = "global";
    
    function show() {
      const inside = "local";
      console.log(level);        // global  (outer variables are visible)
      console.log(inside);       // local
    }
    
    show();
    console.log(typeof inside);  // undefined  (inside does not exist out here)
    
    • Une variable créée à l'intérieur d'une fonction est une variable locale ; chaque appel en reçoit une nouvelle.
    • Passez des valeurs en entrant par les paramètres et obtenez des résultats en sortant via return, au lieu de modifier des variables externes depuis l'intérieur d'une fonction.

    Erreurs courantes

    • Oublier return : la fonction calcule la réponse, puis retourne undefined.
    • Appeler sans parenthèses : greet est la fonction elle-même ; greet("Mei") l'exécute.
    • Imprimer à l'intérieur de la fonction et imprimer son résultat imprime deux fois, ou affiche undefined.
  • 7 Tableaux
    7.1

    Création et modification de tableaux

    Un tableau contient une liste de valeurs dans l'ordre, entre crochets. Chaque élément est un item, et le premier index est 0 :

    const scores = [72, 88, 95];
    console.log(scores[0]);        // 72
    console.log(scores.length);    // 3
    scores[1] = 90;                // change one element
    console.log(scores);           // [72,90,95]
    
    • const empêche de donner à scores un tout nouveau tableau, mais vous pouvez toujours modifier ce qu'il contient.
    • Lire au-delà de la fin donne undefined : scores[3] est undefined.

    Ajoutez et retirez à la fin avec push et pop :

    const queue = ["Ann", "Ben"];
    queue.push("Cai");             // add to the end
    console.log(queue);            // ["Ann","Ben","Cai"]
    const last = queue.pop();      // remove from the end and return it
    console.log(last);             // Cai
    console.log(queue.length);     // 2
    

    Un tableau peut contenir des tableaux. Cela crée une grille, lue avec deux indices, ligne d'abord :

    const grid = [
      [1, 2, 3],
      [4, 5, 6],
    ];
    console.log(grid[1][2]);       // 6  (row 1, column 2)
    
    7.2

    map, filter et reduce

    Ces méthodes prennent une fonction et l'appliquent aux éléments du tableau. Elles retournent un nouveau tableau (ou valeur) sans remplacer elles-mêmes les éléments originaux. La fonction que vous passez peut toujours modifier le tableau original ou ses objets :

    • map crée un nouveau tableau en modifiant chaque élément.
    • filter conserve uniquement les éléments pour lesquels la fonction retourne true.
    • reduce combine tous les éléments en une seule valeur, comme une somme totale.
    const prices = [4, 10, 25];
    const withTax = prices.map((p) => p * 1.1);
    console.log(withTax.map((p) => p.toFixed(2)));   // ["4.40","11.00","27.50"]
    
    const cheap = prices.filter((p) => p < 20);
    console.log(cheap);                              // [4,10]
    
    const total = prices.reduce((sum, p) => sum + p, 0);
    console.log(total);                              // 39
    

    Dans reduce, sum est l'accumulateur. Il commence par le dernier argument (0) et prend le résultat de la fonction après chaque élément.

    7.3

    Recherche & tri

    sort() sans fonction de comparaison trie les nombres comme du texte
    Méthode Retourne Exemple avec [5, 8, 2] Résultat
    .includes(x) true ou false .includes(8) true
    .indexOf(x) l'index initial de x, ou -1 .indexOf(2) 2
    .find(f) le premier élément où f est vrai .find((n) => n > 6) 8
    .findIndex(f) son index, ou -1 .findIndex((n) => n > 6) 1

    sort classe les éléments dans l'ordre. Sans fonction, il les trie comme du texte, donc les nombres sortent dans le mauvais ordre :

    const nums = [10, 9, 100, 1];
    console.log([...nums].sort());                   // [1,10,100,9]   (as text!)
    console.log([...nums].sort((a, b) => a - b));    // [1,9,10,100]
    console.log([...nums].sort((a, b) => b - a));    // [100,10,9,1]
    
    • La fonction de comparaison retourne un nombre négatif lorsque a doit venir en premier, et un nombre positif lorsque b doit.
    • sort modifie le tableau lui-même. [...nums] fait d'abord une copie, donc nums conserve son ordre.

    Erreurs courantes

    • Le dernier élément est arr[arr.length - 1], pas arr[arr.length].
    • map et filter ne modifient pas le tableau : stockez leur résultat.
    • nums.sort() sur des nombres les trie comme du texte. Passez (a, b) => a - b.
  • 8 Objets
    8.1

    Objets & propriétés

    Un objet regroupe des valeurs liées sous des noms. Chaque paire nom-valeur est une propriété. Le nom est appelé la clé :

    const pupil = {
      name: "Mei",
      age: 17,
      form: "11A",
    };
    console.log(pupil.name);       // Mei
    console.log(pupil["form"]);    // 11A  (bracket form, with the key as a string)
    
    • Lisez une propriété avec un point (pupil.age) ou avec des crochets (pupil["age"]). Utilisez les crochets lorsque la clé est dans une variable : pupil[field].
    • Une clé inexistante renvoie undefined.

    Modifier une propriété ou en ajouter une nouvelle en lui attribuant une valeur :

    const pupil = { name: "Mei", age: 17 };
    pupil.age = 18;                // change
    pupil.house = "Red";           // add
    console.log(pupil);            // {"name":"Mei","age":18,"house":"Red"}
    
    8.2

    Tableaux d'objets

    Une liste de registres est un tableau d'objets. Combinez-le avec les méthodes de tableau du sujet 7 :

    const pupils = [
      { name: "Mei", mark: 88 },
      { name: "Tom", mark: 64 },
      { name: "Sara", mark: 95 },
    ];
    
    const passed = pupils.filter((p) => p.mark >= 70);
    console.log(passed.map((p) => p.name));            // ["Mei","Sara"]
    
    const best = [...pupils].sort((a, b) => b.mark - a.mark)[0];
    console.log(`${best.name} has the top mark`);       // Sara has the top mark
    

    Pour totaliser une propriété, utilisez reduce ou une boucle :

    const pupils = [{ mark: 88 }, { mark: 64 }, { mark: 95 }];
    let sum = 0;
    for (const p of pupils) {
      sum += p.mark;
    }
    console.log((sum / pupils.length).toFixed(1));      // 82.3
    
    8.3

    Parcourir un objet

    Object.keys donne un tableau des clés, et Object.entries donne [key, value] paires, vous pouvez donc les parcourir :

    const stock = { pens: 12, rulers: 0, books: 5 };
    
    console.log(Object.keys(stock));             // ["pens","rulers","books"]
    
    for (const [item, count] of Object.entries(stock)) {
      if (count === 0) {
        console.log(`${item}: sold out`);
      }
    }
    // rulers: sold out
    

    Un objet est un bon compteur : utilisez chaque élément compté comme une clé.

    const words = ["red", "blue", "red", "red"];
    const counts = {};
    for (const w of words) {
      counts[w] = (counts[w] || 0) + 1;   // 0 the first time the key is seen
    }
    console.log(counts);                  // {"red":3,"blue":1}
    

    Erreurs courantes

    • pupil.field recherche une clé nommée field. Lorsque la clé se trouve dans une variable, écrivez pupil[field].
    • Une virgule sépare les propriétés, pas un point-virgule : { name: "Mei", age: 17 }.
    • for...of ne peut pas parcourir un objet directement. Parcourez Object.keys(...) ou Object.entries(...).
  • 9 Erreurs
    9.1

    Lecture des messages d'erreur

    Lorsque JavaScript ne peut pas continuer, il s'arrête et affiche une erreur. Le premier mot nomme le type d'erreur ; la suite explique ce qui a mal tourné et où. Lisez-le, puis vérifiez la ligne qu'il mentionne.

    SyntaxError: missing ) after argument list
    ReferenceError: totl is not defined
    TypeError: Cannot read properties of undefined (reading 'length')
    
    Erreur Signification Cause typique
    SyntaxError le code n'est pas correctement écrit, rien ne s'exécute une parenthèse ou une guillemet manquant
    ReferenceError un nom inexistant une faute de frappe : totl pour total
    TypeError la valeur est du mauvais type par rapport à l'action entreprise utiliser .length sur undefined

    La formulation exacte peut varier selon les navigateurs, mais le nom de l'erreur reste identique. Ce programme intercepte chaque erreur afin d'en afficher le nom :

    try {
      const total = 5;
      console.log(totl);
    } catch (e) {
      console.log(e.name);           // ReferenceError
    }
    
    try {
      const pupil = undefined;
      console.log(pupil.length);
    } catch (e) {
      console.log(e.name);           // TypeError
    }
    

    Certaines erreurs ne génèrent aucun message, seulement une réponse incorrecte : une erreur logique. Pour la détecter, imprimez les valeurs intermédiaires avec console.log et vérifiez-les manuellement.

    9.2

    try, catch et throw

    Le code susceptible d'échouer se place dans un bloc try. Si une erreur survient, JavaScript saute vers catch au lieu de s'arrêter, et e contient l'erreur :

    try {
      JSON.parse("{not valid}");
      console.log("parsed");         // skipped
    } catch (e) {
      console.log("Could not read the data");
    }
    console.log("The program carries on");
    

    Votre propre code peut lever une erreur avec throw. Cela permet à une fonction de refuser clairement des entrées invalides, au lieu de retourner une réponse erronée :

    function average(list) {
      if (list.length === 0) {
        throw new Error("the list is empty");
      }
      return list.reduce((s, x) => s + x, 0) / list.length;
    }
    
    console.log(average([4, 6]));    // 5
    try {
      average([]);
    } catch (e) {
      console.log(`Error: ${e.message}`);   // Error: the list is empty
    }
    
    • new Error("…") crée une erreur dont la message est votre texte.
    • N'utilisez try qu'autour du code susceptible vraiment d'échouer, comme la lecture de données. Ne l'utilisez pas pour dissimuler des erreurs dans votre propre code.

    Erreurs courantes

    • Ignorer le message. Sa première ligne nomme le type d'erreur et ce qui a mal tourné ; commencez par là.
    • Un catch qui ne fait rien (catch (e) {}) cache le problème : imprimez au moins e.message.
    • Le throw "text" fonctionne, mais le throw new Error("text") enregistre également l'emplacement où l'erreur s'est produite.

Se connecter ou créer un compte

IGCSE, A-Level & AP