Gestion des erreurs en JavaScript

Cet article explique la gestion des erreurs en JavaScript.

YouTube Video

Gestion des erreurs en JavaScript

La gestion des erreurs en JavaScript est une fonctionnalité importante pour intercepter et gérer correctement les erreurs lorsque un programme rencontre des problèmes inattendus. Principalement, il est courant d'utiliser la syntaxe try...catch pour intercepter et gérer les erreurs. En outre, lors du traitement de Promesses ou d'opérations asynchrones, la gestion des erreurs peut également être réalisée avec async/await ou Promise.prototype.catch.

Syntaxe try...catch

try...catch est utilisé pour intercepter et gérer les erreurs lorsqu'elles se produisent dans un bloc de code.

 1try {
 2    // Code that may throw an error
 3    let result = riskyFunction();
 4    console.log(result);
 5} catch (error) {
 6    // Catch and handle the error
 7    console.error("An error occurred:", error.message);
 8} finally {
 9    // Code that will always execute
10    console.log("Error handling has completed.");
11}

• Si une erreur se produit dans un bloc try, l'exécution du programme est interrompue et le bloc catch est exécuté.
• Le bloc finally est toujours exécuté, qu'il y ait ou non une erreur. Il est utile pour libérer des ressources et effectuer un traitement final, entre autres.

Lancer des erreurs (throw)

En JavaScript, vous pouvez explicitement déclencher une erreur à l'aide du mot-clé throw. Il est utilisé pour lancer des messages d'erreur personnalisés ou des erreurs personnalisées.

 1function checkAge(age) {
 2    if (age < 18) {
 3        throw new Error("You are under 18 years old.");
 4    }
 5    return "Age verification completed.";
 6}
 7
 8try {
 9    let result = checkAge(15);
10    console.log(result);
11} catch (error) {
12    console.error(error.message);  // Displays "You are under 18 years old."
13}

Gestion des erreurs dans les opérations asynchrones (Promise et async/await)

Lors des opérations asynchrones, la gestion des erreurs est légèrement différente. Lors de l'utilisation de Promesses, les erreurs sont interceptées avec la méthode catch.

1let promise = new Promise((resolve, reject) => {
2    // Asynchronous operation
3    setTimeout(() => reject(new Error("An issue has occurred!")), 1000);
4});
5
6promise
7    .then(result => console.log(result))
8    .catch(error => console.error(error.message));  // Displays "An issue has occurred!"

Lors des opérations asynchrones avec async/await, vous pouvez gérer les erreurs avec try...catch.

 1async function fetchData() {
 2    try {
 3        let response = await fetch('https://api.example.com/data');
 4        let data = await response.json();
 5        console.log(data);
 6    } catch (error) {
 7        console.error("An error occurred while fetching data:", error.message);
 8    }
 9}
10
11fetchData();

Résumé

• Vous pouvez intercepter les erreurs synchrones à l'aide de la syntaxe try...catch.
• Vous pouvez lancer vos propres erreurs avec throw.
• Les erreurs dans les opérations asynchrones peuvent être gérées à l'aide de la méthode catch de Promise, ou avec async/await et try...catch.

En utilisant ces méthodes, vous pouvez vous assurer que votre programme fonctionne correctement même en cas d'erreurs.

Error

La classe Error est utilisée pour la gestion des erreurs. Elle permet de créer des erreurs et de fournir des messages d'erreur et des traces d'exécution.

1try {
2    throw new Error("Something went wrong");
3} catch (e) {
4    console.log(e.message); // Something went wrong
5}

Utilisation de base

Un objet Error peut être explicitement créé lorsqu'une erreur se produit. Vous créez une instance avec new Error() et transmettez un message d'erreur.

1const error = new Error("Something went wrong");
2console.log(error.message);  // "Something went wrong"
3console.log(error.name);     // "Error"
4console.log(error.stack);    // Stack trace (information about where the error occurred)

Lancer des erreurs avec throw

En JavaScript, vous pouvez lancer une erreur en utilisant le mot-clé throw. Cela est utilisé pour interrompre le traitement dans des situations spécifiques et transmettre le contrôle à un gestionnaire d'erreurs.

1function doSomething() {
2    throw new Error("This function is not yet implemented");
3}
4
5try {
6    doSomething();
7} catch (e) {
8    console.error(e.message);  // "This function is not yet implemented"
9}

Les erreurs lancées avec throw peuvent être interceptées en utilisant la syntaxe try...catch.

Créer des erreurs personnalisées

En JavaScript, vous pouvez créer vos propres erreurs personnalisées en étendant la classe Error. Cela vous permet de créer des erreurs adaptées à des situations spécifiques.

 1class CustomError extends Error {
 2    constructor(message) {
 3        super(message);  // Call the parent class constructor
 4        this.name = "CustomError";  // Set the error name
 5    }
 6}
 7
 8try {
 9    throw new CustomError("A custom error has occurred");
10} catch (e) {
11    console.error(e.name);    // "CustomError"
12    console.error(e.message); // "A custom error has occurred"
13}

Classes d'erreurs intégrées

JavaScript dispose de plusieurs classes d'erreurs intégrées qui étendent la classe Error. Celles-ci sont utilisées pour représenter des erreurs spécifiques.

• ReferenceError : Se produit lorsque vous faites référence à une variable qui n'existe pas.
• TypeError : Se produit lorsque le type d'une valeur est différent du type attendu.
• RangeError : Se produit lorsqu'un nombre est en dehors de la plage autorisée.
• SyntaxError : Se produit lorsqu'un code qui n'est pas syntaxiquement correct est exécuté.
• EvalError : Erreurs liées à l'utilisation de la fonction eval(). Il est rarement utilisé de nos jours.
• URIError : Se produit lorsqu'une URI invalide (erreurs de codage ou de décodage) est utilisée.

Exemple : ReferenceError

Voici un exemple de ReferenceError.

1try {
2    console.log(undefinedVariable);  // Undefined variable
3} catch (e) {
4    console.error(e.name);    // "ReferenceError"
5    console.error(e.message); // "undefinedVariable is not defined"
6}

Exemple : TypeError

Voici un exemple de TypeError.

1try {
2    null.f();  // Attempting to call a function on null
3} catch (e) {
4    console.error(e.name);    // "TypeError"
5    console.error(e.message); // "Cannot read properties of null (reading 'f')"
6}

Bloc finally

Dans la syntaxe try...catch, utilisez le bloc finally pour les opérations que vous souhaitez exécuter, qu'une erreur se produise ou non.

1try {
2    throw new Error("An issue has occurred");
3} catch (e) {
4    console.error(e.message);  // "An issue has occurred"
5} finally {
6    console.log("Performing cleanup");
7}

Dans cet exemple, les opérations du bloc finally sont exécutées même si une erreur est levée.

Propriétés de l'objet Error

L'objet Error possède les propriétés suivantes.

• message : Il s'agit du message d'erreur.
• name : Le nom de l'erreur, qui est par défaut "Error".
• stack : Une trace de pile indiquant où l'erreur s'est produite, utile pour le débogage.

Avantages de la gestion des exceptions

En implémentant correctement la gestion des erreurs, vous pouvez empêcher l'application de planter en cas de comportement inattendu. En utilisant correctement la syntaxe try...catch et les objets d'erreur, vous pouvez écrire un code plus robuste.

 1function divide(a, b) {
 2    if (b === 0) {
 3        throw new Error("Cannot divide by zero");
 4    }
 5    return a / b;
 6}
 7
 8try {
 9    console.log(divide(4, 0));  // An error will occur
10} catch (e) {
11    console.error(e.message);   // "Cannot divide by zero"
12}

Résumé

• La classe Error est utilisée pour représenter une cause d'erreur et pour effectuer la gestion des erreurs.
• Utilisez la syntaxe try...catch...finally pour gérer les erreurs et éviter l'arrêt inattendu de l'application.
• Il est également possible d'étendre la classe Error pour créer des erreurs personnalisées.
• Vous pouvez gérer différents types d'erreurs en utilisant des classes d'erreurs intégrées comme TypeError et ReferenceError.

Vous pouvez suivre l'article ci-dessus avec Visual Studio Code sur notre chaîne YouTube. Veuillez également consulter la chaîne YouTube.

YouTube Video