try...catch

Baseline Widely available

Cette fonctionnalité est bien établie et fonctionne sur de nombreux appareils et versions de navigateurs. Elle est disponible sur tous les navigateurs depuis ⁨juillet 2015⁩.

L'instructiontry...catch regroupe des instructions à exécuter et définit une réponse si l'une de ces instructions provoque une exception.

Exemple interactif

try {  nonExistentFunction();} catch (error) {  console.error(error);  // Expected output: ReferenceError: nonExistentFunction is not defined  // (Note: the exact output may be browser-dependent)}

Syntaxe

try {  instructions_try}catch (exception_var_1 if condition_1) { // non-standard  instructions_catch_1}…catch (exception_var_2) {  instructions_catch_2}finally {  instructions_finally}

instructions_try: Les instructions qu'on souhaite exécuter.
instructions_catch_1,instructions_catch_2: Les instructions à exécuter si une exception est levée dans le bloctry.
exception_var_1,exception_var_2: Un identifiant qui permet de récupérer la valeur de l'exception associée à la clausecatch.
condition_1: Une expression conditionnelle.
instructions_finally: Les instructions à exécuter une fois que l'instructiontry est terminée. Ces instructions s'exécuteront, qu'il y ait eu une exception ou non.

L'instructiontry est composée d'un bloctry contenant une ou plusieurs instructions, d'au moins une clausecatch ou d'une clausefinally ou des deux. On peut donc avoir les trois formes suivantes pour cette instruction :

try…catch
try…finally
try…catch…finally

Une clausecatch contient les instructions à exécuter si une exception est levée par une instruction du bloctry. On souhaite généralement que le bloctry se déroule sans problème. Si toutefois une erreur se produit, on veut pouvoir contrôler ce qui se passe et on transmet donc le contrôle au bloccatch. Si une instruction contenue dans le bloctry (ou une fonction appelée depuis le bloctry) renvoie une exception, le contrôle sera immédiatement passé à la clausecatch. Si aucune exception n'est levée, la clausecatch ne sera pas utilisée.

La clausefinally s'exécute après le bloctry et après le bloccatch (si celui-ci a été déclenché) mais avant les instructions qui suivent. Les instructions de cette clause sont toujours exécutées, qu'il y ait eu ou non une exception de déclenchée et/ou d'interceptée.

Il est possible d'imbriquer plusieurs instructionstry. Si untry imbriqué ne possède pas de clausecatch, la clausecatch dutry du niveau supérieur sera utilisée (et ainsi de suite).

Pour plus d'informations sur les exceptions et les erreurs en JavaScript, voir le chapitre duGuide JavaScript correspondant.

Clause`catch` inconditionnelle

Lorsqu'une seule clausecatch inconditionnelle est utilisée, le bloccatch est utilisée pour n'importe quelle exception qui est levée. Ainsi, dans le fragment de code qui suit, pour toute exception produite, le contrôle de l'exécution passera à la clausecatch.

try {  throw "monException"; // génère une exception} catch (e) {  // les instructions utilisées pour gérer les  // exceptions  logErreurs(e); // on transfère l'objet de l'exception à une méthode  // gestionnaire}

La clausecatch définit un identifiant (dans l'exemple précédent, c'este) qui contient la valeur définie par l'instructionthrow. Ce bloccatch est en quelque sorte unique en JavaScript car l'identifiant est créé lors de l'entrée dans le bloccatch, la valeur est alors ajoutée à la portée courant et la durée de vie de l'identifiant est limitée au bloccatch. Une fois que le bloccatch a été exécuté, l'identifiant n'est plus disponible.

Clauses`catch` conditionnelles

Non standard: Cette fonctionnalité n'est pas standardisée. Nous déconseillons d'utiliser des fonctionnalités non standard en production, car leur prise en charge par les navigateurs est limitée, et elles peuvent être modifiées ou supprimées. Toutefois, elles peuvent constituer une alternative appropriée dans certains cas où aucune option standard n'existe.

Il est aussi possible d'utiliser une ou plusieurs clausescatch conditionnelles afin de gérer des exceptions spécifiques. Dans ce cas, selon l'exception produite, la clausecatch appropriée sera utilisée. Dans l'exemple qui suit, le code contenu dans le bloctry peut produire trois exceptions :TypeError,RangeError, etEvalError. Lorsqu'une exception se produit, le contrôle de l'exécution est passé à la clausecatch correspondante. SI l'exception qui est déclenchée ne correspond à aucune des conditions, le contrôle passera à la clausecatch non-conditionnelle si elle est trouvée..

Si on utilise une clausecatch inconditionnelle avec une ou plusieurs clausescatch conditionnelles, la clause inconditionnelle doit être spécifiée en dernière. Si ce n'est pas le cas, la clausecatch inconditionnelle interceptera tous les types d'exceptions avant les autres clauses.

try {    maRoutine(); // peut déclencher trois types d'exceptions} catch (e if e instanceof TypeError) {    // les instructions pour gérer TypeError} catch (e if e instanceof RangeError) {    // les instructions pour gérer RangeError} catch (e if e instanceof EvalError) {    // les instructions pour gérer EvalError} catch (e) {    // les instructions pour gérer les autres exceptions}

Dans le fragment de code qui suit, on aura le même fonctionnement mais en utilisant uniquement des fonctionnalités standard (selon ECMAScript). Ce code est plus long mais fonctionne pour tous les environnements conformes à ECMAScript :

try {  maRoutine(); // may throw three types of exceptions} catch (e) {  if (e instanceof TypeError) {    // les instructions pour gérer TypeError  } else if (e instanceof RangeError) {    // les instructions pour gérer RangeError  } else if (e instanceof EvalError) {    // les instructions pour gérer EvalError  } else {    // les instructions pour gérer les autres exceptions  }}

L'identifiant de l'exception

Lorsqu'une exception est levée dans le bloctry,exception_var (par exemple lee dans «catch (e) ») contient la valeur définie par l'instructionthrow. Cet identifiant peut être utilisé pour accéder aux propriétés de l'objet et ainsi obtenir des informations sur l'exception qui a eu lieu. Cet identifiant est local à la clausecatch, il est créé lorsqu'on rentre dans la clausecatch et n'est plus disponible une fois que la clause a fini son exécution.

function isValidJSON(txt) {  try {    JSON.parse(txt);    return true;  } catch {    return false;  }}

La clause`finally`

La clausefinally contient les instructions à exécuter après que les instructions du bloctry et éventuellement celles de la clausecatch aient été exécutées mais avant que les instructions suivant l'instructiontry soient exécutées. La clausefinally est exécutée dans tous les cas (si on a eu une exception ou non). Si une exception est levée et qu'il n'y a pas de clausecatch, les instructions de la clausefinally sont tout de même exécutées.

Cela peut paraître étrange qu'un bloc de code qui s'exécute même lorsqu'il y a une exception… Il faut comprendre que le code qui suit le bloc try...catch ne serapas exécuté. Aussi, le blocfinally permet de contenir toutes les instructions de clôture/nettoyage nécessaire. On évite donc de dupliquer ce code qui doit toujours être utilisé.

La clausefinally peut être utilisée afin d'exécuter les actions nécessaires pour que le script « échoue correctement » en cas d'erreur. On peut par exemple tirer parti definally pour fermer un flux, libérer une ressource, etc. Dans l'exemple suivant, exécuté côté serveur, le script accède à un fichier. Si une exception se produit lorsque le fichier est ouvert, la clausefinally permet de fermer le fichier avant que le script échoue. Le code contenu dans le blocfinally sera exécuté même si on a une instructionreturn dans la sectiontry ou dans la sectioncatch.

ouvrirMonFichier();try {  // on utilise une ressource  écrireDansMonFichier(mesDonnées);} finally {  fermerMonFichier(); // on ferme toujours la ressource}

Exemples

Blocs`try` imbriqués

Tout d'abord, on utilise ce fragment de code, qui produit le résultat suivant :

try {  try {    throw new Error("oups");  } finally {    console.log("finally");  }} catch (ex) {  console.error("externe", ex.message);}// Produira dans la console :// "finally"// "externe" "oups"

Et maintenant, si on a déjà intercepté l'exception avec une clausecatch dans le bloc imbriqué :

try {  try {    throw new Error("oups");  } catch (ex) {    console.error("interne", ex.message);  } finally {    console.log("finally");  }} catch (ex) {  console.error("externe", ex.message);}// Produira dans la console:// "interne" "oups"// "finally"

Ensuite, si on propage l'erreur à nouveau :

try {  try {    throw new Error("oups");  } catch (ex) {    console.error("interne", ex.message);    throw ex;  } finally {    console.log("finally");  }} catch (ex) {  console.error("externe", ex.message);}// Produira dans la console :// "interne" "oups"// "finally"// "externe" "oups"

Toute exception ne sera interceptée qu'une seule fois par le bloccatch le plus « proche » à moins qu'elle ne soit retransmise à nouveau. Bien entendu, toute exception qui aura été levée par le bloc interne (il se peut que les instructions d'une clause catch provoquent une erreur) sera interceptée par le bloc externe.

Valeur de retour et bloc`finally`

Lorsque le blocfinally renvoie une valeur, c'est cette valeur qui devient la valeur de retour pour l'ensemble du bloctry-catch-finally et ce, peu importe, s'il y a des instructionsreturn dans les blocstry etcatch. Cela inclue également les exceptions levées dans le bloccatch :

try {  try {    throw new Error("oups");  } catch (ex) {    console.error("interne", ex.message);    throw ex;  } finally {    console.log("finally");    return;  }} catch (ex) {  console.error("externe", ex.message);}// Produira dans la console :// "interne" "oups"// "finally"

Le "oups" externe n'est pas renvoyé car l'instructionreturn est utilisée dans la clausefinally du bloc interne. Cela aurait également été le cas avec n'importe quelle valeur renvoyée par le bloccatch.