Gestion exceptionnelle des exceptions en javascript

Points de base

• La gestion des exceptions de JavaScript est implémentée via l'instruction "Try… Catch… enfin". La clause "Try" contient du code qui peut produire des exceptions, la clause "Catch" est exécutée lorsqu'une exception se produit et la clause "Enfin" sera exécutée quel que soit le résultat.
• JavaScript possède sept objets d'erreur intégrés pour la gestion des exceptions: erreur, rangeerror, référenceur, syntaxerror, typeerror, urierror et évaluorror. Chaque objet représente un type d'erreur spécifique.
• JavaScript permet aux développeurs de lancer leurs propres exceptions en utilisant l'instruction "Throw". Cela peut rendre le code plus facile à déboguer et à maintenir car il permet la création de messages d'erreur significatifs.
• peut créer des types d'exceptions personnalisés en étendant le type "Erreur" existant. Cela permet une gestion des erreurs plus spécifique et pertinente dans des applications complexes.

Dans le développement de logiciels, la loi de Murphy s'applique également: tout ce qui peut mal tourner va mal. Pour les programmes non simples, la question n'est pas de savoir si fera une erreur, mais quand fera une erreur. Les fonctionnalités standard et incompatibles standard et les fonctionnalités du navigateur ne sont que quelques sources de problèmes potentiels auxquels sont confrontés les développeurs Web. Compte tenu de tous les problèmes qui peuvent survenir, JavaScript a une méthode de traitement des erreurs étonnamment simple - il abandonne et échoue silencieusement. Au moins, c'est le comportement vu par l'utilisateur. En fait, beaucoup de choses se sont passées dans les coulisses. Lorsqu'une instruction JavaScript produit une erreur, il est dit qu'il lance une

Exception

. L'interpréteur JavaScript ne continue pas à exécuter l'instruction suivante, mais vérifie le code de gestion des exceptions. S'il n'y a pas de gestionnaire d'exception, le programme reviendra de toute fonction qui lance l'exception. Cela répétera chaque fonction sur la pile d'appels jusqu'à ce que le gestionnaire d'exceptions soit trouvé ou que la fonction de niveau supérieur soit atteinte, ce qui entraîne la fin du programme. objet d'erreur

Lorsqu'une exception se produit, un objet représentant l'erreur est créé et lancé. Le langage JavaScript définit sept types d'objets d'erreur intégrés. Ces types d'erreur sont la base de la gestion des exceptions. Chaque type d'erreur est décrit en détail ci-dessous. Erreur

"Erreur" Le type est utilisé pour indiquer une exception générale. Ce type d'exception est le plus souvent utilisé pour implémenter des exceptions définies par l'utilisateur. Le sujet de la création d'exceptions définies par l'utilisateur sera revisité plus loin dans cet article. L'objet "Erreur" est instancié en appelant son constructeur, comme le montre l'exemple suivant:

"Erreur" L'objet contient deux propriétés, "nom" et "message". La propriété "Name" spécifie le type d'exception (dans ce cas "erreur"). La propriété "Message" fournit une description plus détaillée de l'exception. "Message" obtient sa valeur de la chaîne transmise au constructeur d'exception. Les types d'exceptions restants représentent des types d'erreurs plus spécifiques, mais ils sont utilisés de la même manière que le type "d'erreur" général.

RangeError

Lorsque le nombre dépasse la plage spécifiée, une exception "RangeError" est générée. Par exemple, les nombres JavaScript ont la méthode TofixEd (), qui prend le paramètre "Digits" pour représenter le nombre de chiffres qui apparaissent après le point décimal. Ce paramètre doit être compris entre 0 et 20 (bien que certains navigateurs prennent en charge une plage plus large). Si la valeur des "chiffres" est en dehors de cette plage, un "RangeError" est lancé. L'exemple suivant le montre.

<code class="language-javascript">var error = new Error("error message");</code>

ReferenceError

Lors de l'accès à des variables inexistantes, une exception "ReferenceError" sera lancée. Ces exceptions se produisent généralement lorsqu'il existe un nom de variable existant mal orthographié. Dans l'exemple suivant, une "Everror" se produit lors de l'accès à la "barre". Notez que cet exemple suppose que la «barre» n'existe dans aucune portée active lors de la tentative d'incrémentation des opérations.

<code class="language-javascript">var pi = 3.14159;

pi.toFixed(100000);  // RangeError</code>

syntaxerror

Lorsque les règles de la langue JavaScript sont violées, une "syntaxerror" sera lancée. Les développeurs familiers avec des langages tels que C et Java sont utilisés pour rencontrer des erreurs de syntaxe pendant la compilation. Cependant, comme JavaScript est une langue interprétée, les erreurs de syntaxe ne sont pas reconnues avant l'exécution du code. Les erreurs de syntaxe sont uniques car elles sont le seul type d'exception à qui ne peut pas être récupéré. L'exemple suivant génère une erreur de syntaxe car l'instruction "IF" n'a pas le bon accolade.

<code class="language-javascript">function foo() {
  bar++;  // ReferenceError
}</code>

TypeError

Lorsque la valeur n'est pas le type attendu, une exception "TypeError" se produit. Essayer d'appeler une méthode d'objet inexistante est une cause courante de ces exceptions. L'exemple suivant crée un objet vide nommé "foo" puis essaie d'appeler sa méthode BAR (). Étant donné que Bar () n'est pas défini, une "TypeError" est lancée lorsque vous essayez de l'appeler.

<code class="language-javascript">if (foo) {  // SyntaxError
  // 缺少右花括号
}</code>

urierror

Lorsque des méthodes telles que Encodeuri () et Decodeuri () rencontrent URI malformé, une exception "Urierror" sera lancée. L'exemple suivant génère un "Urierror" lorsque vous essayez de décoder la chaîne "%". Le caractère "%" indique le début de la séquence d'échappement URI. Puisqu'il n'y a rien après "%" dans cet exemple, la chaîne est une séquence d'échappement non valide et est donc un composant URI malformé.

<code class="language-javascript">var foo = {};

foo.bar(); // TypeError</code>

Evaluerror

Lorsque la fonction EVAL () n'est pas utilisée, une exception "EVALERROR" sera lancée. Ces exceptions ne sont pas utilisées dans la dernière version de la norme ECMAScript. Cependant, afin de maintenir la compatibilité en arrière avec les normes de version plus anciennes, ils sont toujours pris en charge.

Gestion des exceptions

Maintenant que nous savons quelles sont les exceptions, nous devrions apprendre à les empêcher de provoquer le plantage du programme. JavaScript gère les exceptions via l'instruction "Try… Catch… enfin". Un exemple de déclaration courant est illustré ci-dessous.

<code class="language-javascript">decodeURIComponent("%"); // URIError</code>

La première partie de l'instruction "Try ... Catch ... enfin" est la clause "Try". La clause "Try" est requise pour séparer les blocs de code que les programmeurs soupçonnent peuvent générer des exceptions. La clause "Try" doit être suivie d'une ou deux clauses "Catch" et "Enfin".

"Catch" clause

La deuxième partie de "Try… Catch… enfin" est la clause "Catch". La clause "Catch" est un bloc de code qui est exécuté uniquement lorsqu'une exception se produit dans la clause "Try". Bien que la clause "Catch" soit facultative, il est impossible de vraiment gérer les exceptions sans elle. En effet, la clause "Catch" empêche les exceptions de se propager dans la pile d'appels, permettant la récupération du programme. Si une exception se produit dans le bloc "Try", le contrôle est immédiatement transmis à la clause "Catch". L'exception qui se produit est également transmise au bloc "Catch" pour le traitement. L'exemple suivant montre comment utiliser la clause "Catch" pour gérer un "ReferenceError". Notez que l'objet "ReferenceError" peut être utilisé dans la clause "Catch" via la variable "Exception".

<code class="language-javascript">var error = new Error("error message");</code>

Les applications complexes peuvent générer diverses exceptions. Dans ce cas, l'opérateur "instanceof" peut être utilisé pour distinguer divers types d'exceptions. Dans l'exemple suivant, il est supposé que la clause "Try" peut générer plusieurs types d'exceptions. La clause "Catch" correspondante utilise "instanceof" pour gérer séparément les exceptions "TypeError" et "ReferenceError" de tous les autres types d'erreurs.

<code class="language-javascript">var pi = 3.14159;

pi.toFixed(100000);  // RangeError</code>

"Enfin" Clause

La dernière composante de l'instruction "Try… Catch… enfin" est la clause "enfin" facultative. La clause "enfin" est un bloc de code exécuté après les clauses "essai" et "Catch", que ce soit une erreur. La clause "enfin" est utile pour inclure le code de nettoyage (fichiers de clôture, etc.) qui doit être exécutée de toute façon. Notez que la clause "enfin" s'exécute même si une exception non apprise se produit. Dans ce cas, la clause "enfin" est exécutée et l'exception lancée se poursuit normalement.

Une note intéressante sur la clause "Enfin" est que même si la clause "Try" ou "Catch" exécute l'instruction "Return", elle s'exécutera. Par exemple, la fonction suivante renvoie false car la clause "enfin" est le dernier contenu exécuté.

<code class="language-javascript">function foo() {
  bar++;  // ReferenceError
}</code>

en tête d'une exception

JavaScript permet aux programmeurs de lancer leurs propres exceptions via des instructions nommées "Throw". Ce concept peut être un peu déroutant pour les développeurs inexpérimentés. Après tout, les développeurs ont du mal à écrire du code sans erreurs, mais l'instruction "Throw" introduit délibérément des erreurs. Cependant, lancer intentionnellement des exceptions peut en fait rendre le code plus facile à déboguer et à maintenir. Par exemple, en créant des messages d'erreur significatifs, il est plus facile d'identifier et de résoudre les problèmes.

Ce qui suit montre plusieurs exemples de l'instruction "Throw". Il n'y a aucune limite aux types de données qui peuvent être lancés comme exceptions. Il n'y a pas non plus de limite sur le nombre de fois que les mêmes données peuvent être capturées et lancées. En d'autres termes, une exception peut être jetée, prise, puis jetée à nouveau.

<code class="language-javascript">if (foo) {  // SyntaxError
  // 缺少右花括号
}</code>

Alors que l'instruction "Throw" peut être utilisée avec n'importe quel type de données, l'utilisation des types d'exceptions intégrés présente certains avantages. Par exemple, Firefox se spécialise dans ces objets en ajoutant des informations de débogage, telles que les noms de fichiers et les numéros de ligne lorsque des exceptions se produisent.

Par exemple, supposons qu'une opération de division se produit quelque part dans votre application. Puisqu'il peut y avoir une situation où zéro division se produit, la division peut être gênante. Dans JavaScript, ces opérations entraînent "Nan". Cela peut conduire à des résultats déroutants difficiles à déboguer. Si l'application se plaint fort de la division par zéro, la situation sera beaucoup plus simple. L'énoncé "IF" suivant le fait en lançant une exception.

<code class="language-javascript">var error = new Error("error message");</code>

Bien sûr, il peut être plus approprié d'utiliser "RangeError", comme indiqué ci-dessous:

<code class="language-javascript">var pi = 3.14159;

pi.toFixed(100000);  // RangeError</code>

objet d'exception personnalisé objet

Nous venons d'apprendre à générer des messages d'erreur personnalisés à l'aide de types d'exceptions intégrés. Cependant, une autre façon consiste à créer un nouveau type d'exception en étendant le type "Erreur" existant. Étant donné que le nouveau type hérite de "Erreur", il peut être utilisé comme d'autres types d'exceptions intégrés. Bien que cet article ne discute pas de sujets d'héritage en JavaScript, une technique simple est introduite ici.

L'exemple suivant reviendra au problème de la gestion de la division par zéro. Au lieu d'utiliser l'objet "Error" ou "RangeError" comme précédemment, nous voulons créer notre propre type d'exception. Dans cet exemple, nous créons le type d'exception "DivisionByzeroError". La fonction de l'exemple agit comme le constructeur de notre nouveau type. Le constructeur est responsable de l'attribution des attributs "nom" et "message". Les deux dernières lignes de l'exemple permettent au nouveau type de hériter de l'objet "Erreur".

<code class="language-javascript">function foo() {
  bar++;  // ReferenceError
}</code>

choses à retenir

• La déclaration "Try… Catch… enfin" est utilisée pour gérer les exceptions.
• La clause "essayez" identifie le code qui peut produire des exceptions.
La clause "Catch" n'est exécutée que lorsqu'une exception se produit.
La clause "enfin" est toujours exécutée, quoi qu'il arrive.
• L'instruction "Throw" est utilisée pour générer une exception.
• Les objets d'exception personnalisés doivent hériter du type "Erreur" existant.
images de Fotolia

JavaScript Exception Gestion FAQ

Quelle est la différence entre les erreurs de syntaxe et les erreurs d'exécution dans JavaScript?

Les erreurs de syntaxe, également appelées erreurs d'analyse, se produisent au moment de la compilation dans les langages de programmation traditionnels et au moment de l'interprétation en JavaScript. Une erreur de syntaxe se produit lorsque le code est syntaxiquement incorrect et ne peut pas être analysé. Par exemple, si vous oubliez le support de clôture ou utilisez des caractères illégaux, une erreur de syntaxe se produit.

En revanche, une erreur d'exécution se produit lors de l'exécution du programme, après compilation réussie. Ces erreurs sont généralement causées par des opérations illégales effectuées par le code. Par exemple, essayer d'accéder à une variable non définie ou appeler une fonction qui n'existe pas peut entraîner une erreur d'exécution.

Comment gérer les exceptions en JavaScript?

JavaScript fournit une instruction d'essai… Catch pour gérer les exceptions. Le bloc d'essai contient du code qui peut lancer des exceptions, tandis que le bloc de capture contient du code qui sera exécuté si une exception est lancée dans le bloc d'essai. Voici un exemple simple:

<code class="language-javascript">var error = new Error("error message");</code>

Quel est le but du bloc "enfin" en JavaScript?

Le bloc "enfin" dans JavaScript est utilisé pour exécuter du code après les blocs d'essai et de capture, quel que soit le résultat. Cela signifie que le code du bloc "enfin" sera exécuté, que l'exception soit lancée ou non. Il est généralement utilisé pour nettoyer une fois le code exécuté, tels que la fermeture des fichiers ou la compensation des ressources.

Puis-je lancer ma propre exception en javascript?

Oui, JavaScript vous permet de lancer votre propre exception à l'aide de l'instruction "Throw". Vous pouvez lancer n'importe quel type d'exception, y compris les chaînes, les nombres, les valeurs booléennes ou les objets. Une fois une exception lancée, le processus normal du programme sera arrêté et le contrôle sera transmis au gestionnaire d'exceptions le plus récent.

Comment créer un type d'erreur personnalisé dans JavaScript?

JavaScript vous permet de créer des types d'erreur personnalisés en étendant l'objet d'erreur intégré. Ceci est utile lorsque vous souhaitez lancer un type d'erreur spécifique dans votre code. Voici un exemple:

<code class="language-javascript">var pi = 3.14159;

pi.toFixed(100000);  // RangeError</code>

Quelle est la propagation d'erreur dans JavaScript?

La propagation d'erreur fait référence au processus de transmission d'une erreur à partir de l'endroit où il a été jeté au gestionnaire d'exceptions le plus proche de la pile d'appels. Si aucune erreur n'est prise dans la fonction qui lance l'erreur, elle se propagera vers le haut à la fonction d'appel, etc. jusqu'à ce qu'il soit capturé ou atteint la portée globale, à quel point le programme se terminera.

Comment enregistrer les erreurs en JavaScript?

JavaScript fournit la méthode console.error () pour enregistrer les erreurs. Cette méthode fonctionne de la même manière que console.log (), mais il contient également une trace de pile dans le journal et met en évidence le message comme une erreur dans la console. Voici un exemple:

<code class="language-javascript">function foo() {
  bar++;  // ReferenceError
}</code>

Quelle est la différence entre "null" et "Undefined" dans JavaScript?

Dans JavaScript, "null" et "non défini" indiquent des valeurs manquantes. Cependant, ils sont utilisés dans des contextes légèrement différents. "Undefined" signifie qu'une variable a été déclarée mais n'a pas été attribuée de valeur. "Null", d'autre part, est une valeur d'affectation, n'indiquant aucune valeur ou aucun objet.

Comment gérer les erreurs asynchrones en JavaScript?

Les erreurs asynchrones peuvent être manipulées en utilisant la promesse ou l'async / attendre en JavaScript. La promesse a une méthode de «capture» qui est appelée lorsque la promesse est rejetée. Avec Async / Await, vous pouvez utiliser le bloc Try / Catch tout comme vous le feriez avec du code synchrone. Voici un exemple en utilisant Async / Await:

<code class="language-javascript">if (foo) {  // SyntaxError
  // 缺少右花括号
}</code>

Qu'est-ce que TypeError en JavaScript?

Lorsque l'opération ne peut pas être effectuée, généralement lorsque la valeur n'est pas le type attendu, une énergie type est lancée en JavaScript. Par exemple, tenter d'appeler une non-fonction ou un accéder à une propriété non définie entraînera un type EERROR.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!