peu importe notre niveau de programmation, nos scripts comportent parfois des erreurs. Ils peuvent se produire en raison de nos erreurs, d’une entrée utilisateur inattendue, d’une réponse erronée du serveur et pour mille autres raisons.

habituellement, un script « meurt” (s’arrête immédiatement) en cas d’erreur, l’imprimant sur la console.

Mais il existe une construction syntaxiquetry..catch qui nous permet de « détecter” les erreurs afin que le script puisse, au lieu de mourir, faire quelque chose de plus raisonnable.,

Le « try…catch” syntaxe

Le try..catch construire a deux principaux blocs: try, puis catch:

try { // code...} catch (err) { // error handling}

Il fonctionne comme ceci:

1. tout d’Abord, le code dans le try {...} est exécutée.
2. Si il n’y avait pas d’erreurs, alors catch(err) est ignoré: l’exécution atteint la fin de try et s’en va, en sautant catch.,
3. Si une erreur se produit, alors l’exécution detry est arrêtée et le contrôle s’écoule au début decatch(err). La variable err (nous pouvons utiliser n’importe quel nom pour elle) contiendra un objet d’erreur avec des détails sur ce qui s’est passé.

Donc, une erreur à l’intérieur de la balise try {…} bloc ne doit pas tuer le script, nous avons une chance de le manipuler dans la catch.,

regardons quelques exemples.

try { {{{{{{{{{{{{} catch(e) { alert("The engine can't understand this code, it's invalid");}

Erreur de l’objet

Lorsqu’une erreur se produit, JavaScript génère un objet contenant les détails à ce sujet., L’objet est ensuite transmis comme argument de catch:

try { // ...} catch(err) { // <-- the "error object", could use another word instead of err // ...}

Pour le tout intégré dans des erreurs, l’erreur de l’objet a deux propriétés principales:

nameErreur de nom. Par exemple, pour une variable non définie qui est

"ReferenceError".messagemessage textuel sur les détails de l’erreur.

d’autres propriétés non standard sont disponibles dans la plupart des environnements., L’un des plus largement utilisés et pris en charge est:

stackpile d’appels actuelle: une chaîne contenant des informations sur la séquence d’appels imbriqués qui a conduit à l’erreur. Utilisé à des fins de débogage.

Par exemple:

Option « capture” de liaison

Si nous n’avons pas besoin détails de l’erreur, catch peut l’omettre:

try { // ...} catch { // <-- without (err) // ...}

Utilisation de « try…catch”

nous allons explorer un vrai cas d’utilisation de la balise try..catch.

Comme nous le savons déjà, JavaScript prend en charge le JSON.méthode parse (str) pour lire les valeurs codées JSON.

Habituellement, il est utilisé pour décoder les données reçues sur le réseau, à partir du serveur ou d’une autre source.,

nous le recevons et appelonsJSON.parsecomme ceci:

Vous pouvez trouver des informations plus détaillées sur JSON dans le chapitre méthodes JSON, toJSON.

Si json est incorrect, JSON.parse génère une erreur, donc le script « meurt”.

devrions-nous en être satisfaits? Bien sûr que non!

de cette façon, si quelque chose ne va pas avec les données, le visiteur ne le saura jamais (à moins qu’il n’ouvre la console du développeur). Et les gens n’aiment vraiment pas quand quelque chose” meurt  » sans aucun message d’erreur.,

utilisonstry..catch pour gérer l’erreur:

ici, nous utilisons le bloccatch uniquement pour afficher le message, mais nous pouvons faire beaucoup plus: envoyer une nouvelle demande réseau, Suggérer une alternative au visiteur, envoyer des informations sur l’erreur à une installation de journalisation,.. Tout est bien mieux que de mourir.

Jeter nos propres erreurs

si json est syntaxiquement correct, mais n’est pas requise, name propriété?,

let json = '{ "age": 30 }'; // incomplete datatry { let user = JSON.parse(json); // <-- no errors alert( user.name ); // no name!} catch (e) { alert( "doesn't execute" );}

Ici JSON.parse s’exécute normalement, mais l’absence de name est en fait d’une erreur pour nous.

pour unifier la gestion des erreurs, nous utiliserons l’opérateurthrow.

« Jeter” de l’opérateur

Le throw opérateur génère une erreur.

La syntaxe est:

throw <error object>

Techniquement, on peut utiliser n’importe quoi comme un objet d’erreur., Cela peut même être une primitive, comme un nombre ou une chaîne, mais il est préférable d’utiliser des objets, de préférence avec les propriétés name et message (pour rester quelque peu compatible avec les erreurs intégrées).

JavaScript a de nombreuses fonctions dans les constructeurs pour les erreurs standard: Error, SyntaxError, ReferenceError, TypeError et les autres. Nous pouvons les utiliser pour créer des objets d’erreur ainsi.,

la syntaxe est:

let error = new Error(message);// orlet error = new SyntaxError(message);let error = new ReferenceError(message);// ...

Pour les erreurs intégrées (pas pour tous les objets, juste pour les erreurs), la balise name propriété est exactement le nom du constructeur. Et message est tiré de l’argument.,

Par exemple:

let error = new Error("Things happen o_O");alert(error.name); // Erroralert(error.message); // Things happen o_O

voyons voir ce genre d’erreur JSON.parse génère:

try { JSON.parse("{ bad json o_O }");} catch(e) { alert(e.name); // SyntaxError alert(e.message); // Unexpected token b in JSON at position 2}

Comme on peut le voir, c’est SyntaxError.

Et dans notre cas, l’absence de name est l’erreur, que les utilisateurs doivent posséder un name.,

Donc, nous allons jeter:

À la ligne (*), le throw opérateur génère une balise SyntaxError avec le message, de la même façon que le JavaScript serait de générer elle-même. L’exécution de try arrête immédiatement et le flux de contrôle saute dans catch.

maintenantcatch est devenu un seul endroit pour toute la gestion des erreurs: à la fois pourJSON.parse et d’autres cas.,

Renvoi

Dans l’exemple ci-dessus, nous utilisons la balise try..catch pour gérer des données incorrectes. Mais est-il possible qu’une autre erreur inattendue se produise dans le bloc try {...}? Comme une erreur de programmation (la variable n’est pas définie) ou autre chose, pas seulement cette chose de « données incorrectes”.

Par exemple:

bien sûr, tout est possible! Les programmeurs font des erreurs. Même dans les utilitaires open source utilisés par des millions de personnes depuis des décennies, un bug peut soudainement être découvert qui conduit à de terribles hacks.,

Dans notre cas, try..catch est placé pour attraper « des données incorrectes” erreurs. Mais de par sa nature, catch obtient toutes les erreurs de try. Ici, il obtient une erreur inattendue, mais affiche toujours le même message "JSON Error". C’est faux et rend également le code plus difficile à déboguer.

pour éviter de tels problèmes, nous pouvons utiliser la technique de « rethrowing”. La règle est simple:

Catch ne devrait traiter que les erreurs qu’il connaît et « repenser” toutes les autres.,

la technique de « rethrowing” peut être expliquée plus en détail comme suit:

1. Catch obtient toutes les erreurs.
2. Dans le catch(err) {...} bloc, nous analysons l’objet d’erreur err.
3. Si nous ne savons pas comment le gérer, nous n’ throw err.

Habituellement, nous pouvons vérifier le type d’erreur en utilisant l’opérateurinstanceof:

Nous pouvons également obtenir le nom de classe d’erreur à partir de la propriétéerr.name. Toutes les erreurs natives l’ont. Une autre option consiste à lire err.constructor.name.,

dans le code ci-dessous, nous utilisons rethrowing de sorte que catch ne gère que SyntaxError:

l’erreur de lancement en ligne (*) de l’intérieur catch et peut être soit intercepté par une construction externe try..catch (si elle existe), soit il tue le script.

ainsi, le bloccatch ne gère en fait que les erreurs qu’il sait gérer et « ignore” toutes les autres.,

L’exemple ci-dessous montre comment de telles erreurs peuvent être pris par l’un plus au niveau de la balise try..catch:

Ici readData ne sait comment gérer SyntaxError, tandis que l’extérieur try..catch sait comment s’occuper de tout.

try catch catch finally enfin

attendez, ce n’est pas tout.

Le try..catch construire peut avoir un plus code article: finally.,

Si elle existe, elle fonctionne dans tous les cas:

• après try, si il n’y a pas d’erreur,
• après catch, si il y avait des erreurs.

La syntaxe ressemble à ceci:

try { ... try to execute the code ...} catch(e) { ... handle errors ...} finally { ... execute always ...}

Essayez d’exécuter ce code:

try { alert( 'try' ); if (confirm('Make an error?')) BAD_CODE();} catch (e) { alert( 'catch' );} finally { alert( 'finally' );}

Le code a deux façons de l’exécution:

1. Si vous répondez « Oui” à « Faire une erreur?” puis try -> catch -> finally.,
2. Si vous dites « Non”, puis try -> finally.

la clause finally est souvent utilisée lorsque nous commençons à faire quelque chose et que nous voulons le finaliser dans tous les cas de résultat.

par exemple, nous voulons mesurer le temps qu’une fonction de nombres de Fibonaccifib(n) prend. Naturellement, nous pouvons commencer à mesurer avant qu’il fonctionne et finir après. Mais que se passe-t-il s’il y a une erreur lors de l’appel de fonction? En particulier, l’implémentation de fib(n) dans le code ci-dessous renvoie une erreur pour les nombres négatifs ou non entiers.,

la clausefinally est un excellent endroit pour terminer les mesures quoi qu’il arrive.

Ici finally garantit que le temps sera mesuré correctement dans deux situations: – en cas d’exécution réussie de fib et dans le cas d’une erreur:

Vous pouvez le vérifier en exécutant le code avec la saisie de 35 dans un prompt – il s’exécute normalement, finally après try., Puis entrez -1 – il y aura une erreur immédiate, et l’exécution prendra 0ms. Les deux mesures sont effectuées correctement.

En d’autres termes, la fonction peut se terminer par return ou throw, qui n’a pas d’importance. La clausefinally s’exécute dans les deux cas.,

function func() { // start doing something that needs completion (like measurements) try { // ... } finally { // complete that thing even if all dies }}

des prises Mondiales,

imaginons que nous ayons une erreur fatale en dehors detry..catch, et le script est mort. Comme une erreur de programmation ou une autre chose terrible.

Est-il un moyen de réagir à de tels événements? On peut vouloir le journal de l’erreur, montrer quelque chose à l’utilisateur (normalement ils ne voient pas les messages d’erreur), etc.

Il n’y en a pas dans la spécification, mais les environnements Le fournissent généralement, car c’est vraiment utile. Par exemple, Node.js a process.on("uncaughtException") pour cela. Et dans le navigateur, nous pouvons attribuer une fonction à la fenêtre spéciale.,propriété onerror, qui s’exécutera en cas d’erreur non interceptée.

La syntaxe:

window.onerror = function(message, url, line, col, error) { // ...};

messagemessage d’Erreur.urlURL du script où l’erreur s’est produite.line,colnombre de lignes et colonnes où l’erreur s’est produite.errorobjet D’erreur.,

par exemple:

le rôle du gestionnaire global window.onerror n’est généralement pas de récupérer l’exécution du script – c’est probablement impossible en cas d’erreurs de programmation, mais d’envoyer le message d’erreur aux développeurs.

ils fonctionnent comme ceci:

1. nous nous inscrivons au service et obtenons un morceau de JS (ou une URL de script) d’eux pour insérer sur les pages.
2. ce script JS définit une fonction window.onerror personnalisée.
3. Lorsqu’une erreur se produit, il envoie une requête réseau à ce sujet au service.
4. nous pouvons nous connecter à l’interface Web du service et voir les erreurs.,

Résumé

Le try..catch construire permet de gérer les erreurs d’exécution. Il permet littéralement d ‘ ” essayer « d’exécuter le code et de” détecter » les erreurs qui peuvent s’y produire.

La syntaxe est:

Il y a peut-être pas de catch section ou pas de finally, donc plus courte constructions try..catch et try..finally sont également valables.

Les objets D’erreur ont les propriétés suivantes:

• message – le message d’erreur lisible par l’homme.,
• name – la chaîne avec le nom d’erreur (Nom du constructeur d’erreur).
• stack (non standard, mais bien pris en charge)-la pile au moment de la création de l’erreur.

Si un objet d’erreur n’est pas nécessaire, nous pouvons l’omettre en utilisantcatch { au lieu decatch(err) {.

nous pouvons également générer nos propres erreurs en utilisant l’opérateurthrow., Techniquement, l’argument de throw peut être n’importe quoi, mais généralement c’est un objet d’erreur héritant de la classe Error intégrée. Plus sur l’extension des erreurs dans le chapitre suivant.

Rethrowing est un modèle très important de gestion des erreurs: un bloccatch attend généralement et sait comment gérer le type d’erreur particulier, il devrait donc rethrow les erreurs qu’il ne connaît pas.

même si nous n’avons pastry..catch, la plupart des environnements nous permettent de configurer un gestionnaire d’erreurs « global” pour détecter les erreurs qui « tombent”., Dans le navigateur, c’est window.onerror.