JavaScript
La gestion des erreurs

Syntaxe

• essayez {…} attraper (erreur) {…}
• essayez {…} enfin {…}
• essayez {…} attraper (erreur) {…} enfin {…}
• lancer une nouvelle erreur ([message]);
• jeter l'erreur ([message]);

Remarques

Interaction avec les promesses

Promise.resolve(5)
    .then(result => {
        throw new Error("I don't like five");
    })
    .then(result => {
        console.info("Promise resolved: " + result);
    })
    .catch(error => {
        console.error("Promise rejected: " + error);
    });

Promise rejected: Error: I don't like five

async function main() {
  try {
    await Promise.reject(new Error("Invalid something"));
  } catch (error) {
    console.log("Caught error: " + error);
  }
}
main();

Caught error: Invalid something

Objets d'erreur

Les erreurs d'exécution en JavaScript sont des instances de l'objet Error . L'objet Error peut également être utilisé tel quel ou comme base pour les exceptions définies par l'utilisateur. Il est possible de lancer n'importe quel type de valeur - par exemple, des chaînes - mais vous êtes fortement encouragé à utiliser Error ou l'un de ses dérivés pour vous assurer que les informations de débogage, telles que les traces de pile, sont correctement conservées.

Le premier paramètre du constructeur d' Error est le message d'erreur lisible par l'homme. Vous devriez toujours essayer de spécifier un message d'erreur utile sur ce qui a mal tourné, même si des informations supplémentaires peuvent être trouvées ailleurs.

try {
   throw new Error('Useful message');
} catch (error) {
   console.log('Something went wrong! ' + error.message);
}

Ordre des opérations plus pensées avancées

Sans try catch block, les fonctions non définies lanceront des erreurs et arrêteront l'exécution:

undefinedFunction("This will not get executed");
console.log("I will never run because of the uncaught error!");

Va lancer une erreur et ne pas exécuter la deuxième ligne:

// Uncaught ReferenceError: undefinedFunction is not defined

Vous avez besoin d'un bloc try catch, similaire aux autres langages, pour vous assurer que cette erreur est détectée afin que le code puisse continuer à s'exécuter:

try {
    undefinedFunction("This will not get executed");
} catch(error) {
    console.log("An error occured!", error);
} finally {
    console.log("The code-block has finished");
}
console.log("I will run because we caught the error!");

Maintenant, nous avons détecté l'erreur et pouvons être sûrs que notre code va être exécuté

// An error occured! ReferenceError: undefinedFunction is not defined(…)
// The code-block has finished
// I will run because we caught the error!

Que se passe-t-il si une erreur se produit dans notre bloc catch?

try {
    undefinedFunction("This will not get executed");
} catch(error) {
    otherUndefinedFunction("Uh oh... ");
    console.log("An error occured!", error);
} finally {
    console.log("The code-block has finished");
}
console.log("I won't run because of the uncaught error in the catch block!");

Nous ne traiterons pas le reste de notre bloc catch, et l'exécution s'arrêtera sauf pour le bloc finally.

// The code-block has finished
// Uncaught ReferenceError: otherUndefinedFunction is not defined(…)

Vous pouvez toujours imbriquer vos blocs de capture, mais vous ne devriez pas le faire car cela deviendra extrêmement désordonné.

try {
    undefinedFunction("This will not get executed");
} catch(error) {
    try {
        otherUndefinedFunction("Uh oh... ");
    } catch(error2) {
        console.log("Too much nesting is bad for my heart and soul...");
    }
    console.log("An error occured!", error);
} finally {
    console.log("The code-block has finished");
}
console.log("I will run because we caught the error!");

Va attraper toutes les erreurs de l'exemple précédent et enregistrer les éléments suivants:

//Too much nesting is bad for my heart and soul...
//An error occured! ReferenceError: undefinedFunction is not defined(…)
//The code-block has finished
//I will run because we caught the error!

Alors, comment pouvons-nous attraper toutes les erreurs !? Pour les variables et fonctions non définies: vous ne pouvez pas.

En outre, vous ne devez pas envelopper chaque variable et chaque fonction dans un bloc try / catch, car ce sont des exemples simples qui ne se produiront qu'une seule fois jusqu'à ce que vous les répariez. Cependant, pour les objets, fonctions et autres variables que vous connaissez, mais vous ne savez pas si leurs propriétés, sous-processus ou effets secondaires existeront, ou si vous vous attendez à des erreurs dans certaines circonstances, vous devez abstraire votre gestion des erreurs. d'une manière ou d'une autre. Voici un exemple très basique et une implémentation.

Sans moyen protégé d'appeler des méthodes de diffusion non fiables ou d'exception:

function foo(a, b, c) {
    console.log(a, b, c);
    throw new Error("custom error!");
}
try {
    foo(1, 2, 3);
} catch(e) { 
    try {
        foo(4, 5, 6); 
    } catch(e2) {
        console.log("We had to nest because there's currently no other way...");
    }
    console.log(e);
}
// 1 2 3
// 4 5 6
// We had to nest because there's currently no other way...
// Error: custom error!(…)

Et avec protection:

function foo(a, b, c) {
    console.log(a, b, c);
    throw new Error("custom error!");
}
function protectedFunction(fn, ...args) {
    try {
        fn.apply(this, args);
    } catch (e) {
        console.log("caught error: " + e.name + " -> " + e.message);
    }
}

protectedFunction(foo, 1, 2, 3);
protectedFunction(foo, 4, 5, 6);

// 1 2 3
// caught error: Error -> custom error!
// 4 5 6
// caught error: Error -> custom error!

Nous interceptons les erreurs et traitons toujours tout le code attendu, mais avec une syntaxe quelque peu différente. Dans les deux cas, cela fonctionnera, mais au fur et à mesure que vous construirez des applications plus avancées, vous souhaiterez commencer à réfléchir aux moyens d’abstraire votre gestion des erreurs.

Types d'erreur

Il existe six constructeurs d’erreur de noyau spécifiques en JavaScript:

• EvalError - crée une instance représentant une erreur concernant la fonction globale eval() .

• InternalError - crée une instance représentant une erreur qui se produit lorsqu'une erreur interne du moteur JavaScript est générée. Par exemple, "trop ​​de récursivité". (Uniquement pris en charge par Mozilla Firefox )

• RangeError - crée une instance représentant une erreur qui se produit lorsqu'une variable ou un paramètre numérique est en dehors de sa plage valide.

• ReferenceError - crée une instance représentant une erreur qui survient lors du déréférencement d'une référence non valide.

• SyntaxError - crée une instance représentant une erreur de syntaxe qui se produit lors de l'analyse du code dans eval() .

• TypeError - crée une instance représentant une erreur qui se produit lorsqu'une variable ou un paramètre n'est pas d'un type valide.

• URIError - crée une instance représentant une erreur qui se produit lorsque des paramètres non valides sont transmis à encodeURI() ou decodeURI() .

Si vous implémentez un mécanisme de traitement des erreurs, vous pouvez vérifier le type d'erreur que vous attrapez du code.

try {
    throw new TypeError();
}
catch (e){
    if(e instanceof Error){
        console.log('instance of general Error constructor');
    }

    if(e instanceof TypeError) {
        console.log('type error');
    }
}

Dans ce cas, e sera une instance de TypeError . Tous les types d'erreur étendent le constructeur de base Error , c'est donc aussi une instance d' Error .

Garder cela à l'esprit nous montre que vérifier e être une instance d' Error est inutile dans la plupart des cas.