Gestion des exceptions

10.1 Bloc try...catch

La gestion des exceptions est un aspect important de la programmation qui aide à améliorer la résilience et la fiabilité du code. En JavaScript, pour gérer les exceptions, on utilise les mots-clés try, catch, finally et throw. Dans cette conférence, nous allons examiner ces mots-clés, leur syntaxe et des exemples d'utilisation.

1. Bloc try...catch

La construction try...catch est utilisée pour gérer les erreurs qui se produisent dans le bloc de code try. Si une erreur survient dans le bloc try, le contrôle est transféré au bloc catch, où l'erreur peut être traitée.

Syntaxe :

    
      try {
        // Code qui peut provoquer une exception
      } catch (error) {
        // Code pour traiter l'exception
      }
    
  

Dans cet exemple, bien que la division par zéro ne provoque pas d'erreur en JavaScript, si c'était une autre erreur (par exemple un accès à une variable non définie), le bloc catch la traiterait :

    
      try {
        let result = 10 / 0;

        console.log(result);

      } catch (error) {
        console.error('An error occurred:', error);
      }
    
  

10.2. Bloc finally

Le bloc finally est utilisé pour exécuter du code qui doit être exécuté que l'exception soit levée ou non dans le bloc try. Le bloc finally suit le bloc catch.

Syntaxe :

    
      try {
        // Code qui peut provoquer une exception
      } catch (error) {
        // Code pour traiter l'exception
      } finally {
        // Code qui s'exécutera dans tous les cas
      }
    
  

Dans cet exemple, le message This will always execute. sera affiché que l'erreur soit survenue ou non :

    
      try {
        let result = 10 / 0;
        console.log(result);
      } catch (error) {
        console.error('An error occurred:', error);
      } finally {
        console.log('This will always execute.');
      }
    
  

10. 3. Opérateur throw

L'opérateur throw est utilisé pour lever explicitement des exceptions. Il permet de lancer des erreurs personnalisées.

Syntaxe :

    
      throw expression;
    
  

Où :

• expression : toute expression ou objet qui sera jeté comme exception

Exemple d'utilisation

Dans cet exemple, une erreur est lancée si l'on tente de diviser par zéro, et le bloc catch traite cette erreur :

    
      function divide(a, b) {
        if (b === 0) {
          throw new Error('Division by zero is not allowed.');
        }
        return a / b;
      }

      try {
        let result = divide(10, 0);
        console.log(result);
      } catch (error) {
        console.error('An error occurred:', error.message);
      }
    
  

10.4 Exemples avancés et utilisation

Exemple 1 : Exceptions multiples

Parfois, différents types d'erreurs peuvent survenir dans le bloc try. Vous pouvez les gérer différemment en utilisant les propriétés de l'objet erreur.

Dans cet exemple, nous traitons l'erreur de syntaxe JSON séparément des autres erreurs possibles :

    
      try {
        JSON.parse('{ malformed JSON string }');
      } catch (error) {
        if (error instanceof SyntaxError) {
          console.error('JSON Syntax Error:', error.message);
        } else {
          console.error('Unexpected Error:', error);
        }
      } finally {
        console.log('Parsing attempt finished.');
      }
    
  

Exemple 2 : Blocs try...catch imbriqués

Il est possible d'utiliser des blocs try...catch imbriqués pour une gestion des erreurs plus fine.

Dans cet exemple, l'erreur survenue dans le premier bloc try est traitée par le bloc catch interne, qui relance ensuite l'erreur pour être traitée par le bloc catch externe :

    
      try {
        try {
          let result = divide(10, 0);
          console.log(result);
        } catch (innerError) {
          console.error('Inner catch:', innerError.message);
          throw innerError;
        }
      } catch (outerError) {
        console.error('Outer catch:', outerError.message);
      } finally {
        console.log('Nested try...catch finished.');
      }

      function divide(a, b) {
        if (b === 0) {
          throw new Error('Division by zero is not allowed.');
        }
        return a / b;
      }
    
  

Exemple 3 : Utilisation de finally pour libérer des ressources

Le bloc finally est utile pour libérer des ressources, comme la fermeture de fichiers ou la terminaison de connexions réseau.

Dans cet exemple, le fichier sera toujours fermé, que l'erreur se soit produite ou non lors de sa lecture :

    
      function readFile(filePath) {
        let file;
        try {
          file = openFile(filePath); // Fonction qui ouvre le fichier
          // Travail avec le fichier
        } catch (error) {
          console.error('Error reading file:', error.message);
        } finally {
          if (file) {
            closeFile(file); // Fonction qui ferme le fichier
          }
          console.log('File processing finished.');
        }
      }

      function openFile(path) {
        // Logique d'ouverture du fichier
      }

      function closeFile(file) {
        // Logique de fermeture du fichier
      }

      readFile('path/to/file.txt');
    
  

La gestion des exceptions en JavaScript à l'aide de try, catch, finally et throw permet de créer des applications plus fiables et robustes. Comprendre et bien utiliser ces constructions aide à gérer efficacement les erreurs, libérer les ressources et améliorer l'expérience utilisateur.

1

Étude/Quiz

Objets, niveau 36, leçon 4

Indisponible

Objets

Objets

Ouvrir