Instruction JS try-catch et utilisation du type d'erreur

Cette fois, je vais vous présenter l'utilisation des instructions try-catch et des types d'erreur dans JS. Quelles sont les précautions à prendre pour utiliser les instructions try-catch et les types d'erreur dans JS ? Ce qui suit est un cas pratique, jetons un coup d'œil.

La logique d'application connaît toujours la raison de l'appel d'une fonction particulière et est donc la mieux adaptée pour gérer les erreurs. Ne laissez jamais le bloc catch vide dans un try-catch, vous devez toujours écrire quelque chose pour gérer les erreurs. Par exemple, ne faites pas quelque chose comme ceci :

try {
  somethingThatMightCauseAnError();
} catch (ex) {  // do nothing}

Si vous savez qu'une erreur est susceptible de se produire, vous savez certainement comment la récupérer. La manière exacte de récupérer des erreurs est différente en mode développement et en mode production, et ce n'est pas grave. La chose la plus importante est que vous traitiez réellement l’erreur au lieu de l’ignorer.

La spécification ECMA-262 indique 7 types d'erreurs. Ces types sont utilisés dans le moteur JS lorsque différentes conditions d'erreur se produisent, et bien sûr, nous pouvons également les créer manuellement.

Erreur : le type de base de toutes les erreurs. En fait, le moteur ne génère jamais ce type d'erreur.

EvalError : levée lorsqu'une erreur se produit lors de l'exécution de code via la fonction eval().

RangeError : levée lorsqu'un nombre dépasse ses limites - par exemple, en essayant de créer un tableau de longueur -20 (new Array(-20);). Cette erreur est très rare dans l’exécution normale de code.

ReferenceError : levée lorsque l'objet souhaité n'existe pas - par exemple, en essayant d'appeler une fonction sur une référence d'objet nulle.

SyntaxError : renvoyé lorsque le code contient une erreur de syntaxe.

TypeError : levée lorsque la variable n'est pas du type attendu. Par exemple, new 10 ou « prop » dans true.

URIError : levée lorsqu'une chaîne URI formatée illégalement est transmise à des fonctions telles que encodeURI(), encodeURIComponent(), decodeURI() ou decodeURIComponent().

Comprendre les différents types d'erreurs peut nous aider à les gérer plus facilement. Tous les types d'erreur héritent de Error, donc vérifier leur type avec instanceof Error ne donnera aucune information utile. Les erreurs peuvent être traitées de manière plus fiable en recherchant des types d’erreurs spécifiques.

try {  // 有些代码引发了错误} catch (ex) {  if (ex instanceof TypeError) {    // 处理TypeError错误
  } else if (ex instanceof ReferenceError) {    // 处理ReferenceError错误
  } else {    // 其他处理
  }
}

Si vous lancez votre propre erreur et qu'il s'agit d'un type de données plutôt que d'une erreur, vous pouvez facilement distinguer votre erreur du type d'erreur du navigateur. Cependant, lancer des erreurs de types réels présente plusieurs avantages par rapport au lancement d'objets d'autres types.

Tout d'abord, comme indiqué ci-dessus, les messages d'erreur sont affichés dans le mécanisme normal de gestion des erreurs du navigateur. Deuxièmement, le navigateur attache des informations supplémentaires à l'objet Error généré. Ces informations varient d'un navigateur à l'autre, mais elles fournissent des informations contextuelles sur l'erreur, telles que les numéros de ligne et de colonne, et, dans certains navigateurs, fournissent également des informations sur la pile et le code source. Bien entendu, si vous utilisez le constructeur Error, vous perdez la possibilité de distinguer les erreurs que vous génèrez des erreurs du navigateur.

La solution est de créer votre propre type d'erreur et de le laisser hériter de Error. Cette approche vous permet de fournir des informations supplémentaires différentes de l'erreur générée par le navigateur. Des types d’erreur personnalisés peuvent être créés à l’aide du modèle suivant.

function MyError (message) {  this.message = message;
}
MyError.prototype = new Error();

Ce code comporte deux parties importantes : l'attribut de message, la chaîne de message d'erreur que le navigateur doit connaître ; définir le prototype sur une instance d'Erreur afin qu'il soit identifié auprès du moteur JS. C'est une erreur. objet. Ensuite, vous pouvez lancer un objet instance de MyError afin que le navigateur puisse répondre comme une erreur native.

throw new MyError('Hello World!');

Pour rappel, cette méthode n'affiche pas de messages d'erreur dans IE8 et les navigateurs antérieurs. Au lieu de cela, vous verrez le message générique « Exception levée mais non interceptée ». Le plus grand avantage de cette méthode est que les types d’erreurs personnalisés peuvent détecter leurs propres erreurs.

try {  // 有些代码引发了错误} catch (ex) {  if (ex instanceof MyError) {    // 处理自己的错误
  } else {    // 其他处理
  }
}

Si vous détectez toujours toutes les erreurs lancées par vous-même, alors la petite bêtise d'IE ne sera rien. Les avantages d’un système de gestion des erreurs approprié sont énormes. Cette méthode peut fournir des informations de plus en plus flexibles pour informer les développeurs sur la manière de gérer correctement les erreurs.

Je pense que vous maîtrisez la méthode après avoir lu le cas dans cet article. Pour des informations plus intéressantes, veuillez prêter attention aux autres articles connexes sur le site Web chinois de php !

Lecture recommandée :

Comment éviter les comparaisons nulles dans le développement Web

Pourquoi devez-vous éviter d'utiliser des variables globales dans développement web

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!