try...catch

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 excuter.

instructions_catch_1, instructions_catch_2

Les instructions excuter si une exception est leve dans le bloc try.

exception_var_1, exception_var_2

Un identifiant qui permet de rcuprer la valeur de l'exception associe la clause catch.

condition_1

Une expression conditionnelle.

instructions_finally

Les instructions excuter une fois que l'instruction try est termine. Ces instructions s'excuteront, qu'il y ait eu une exception ou non.

Description

L'instruction try est compose d'un bloc try contenant une ou plusieurs instructions, d'au moins une clause catch ou d'une clause finally ou des deux. On peut donc avoir les trois formes suivantes pour cette instruction :

1. trycatch
2. tryfinally
3. trycatchfinally

Une clause catch contient les instructions excuter si une exception est leve par une instruction du bloc try. On souhaite gnralement que le bloc try se droule sans problme. Si toutefois une erreur se produit, on veut pouvoir contrler ce qui se passe et on transmet donc le contrle au bloc catch. Si une instruction contenue dans le bloc try (ou une fonction appele depuis le bloc try) renvoie une exception, le contrle sera immdiatement pass la clause catch. Si aucune exception n'est leve, la clause catch ne sera pas utilise.

La clause finally s'excute aprs le bloc try et aprs le bloc catch (si celui-ci a t dclench) mais avant les instructions qui suivent. Les instructions de cette clause sont toujours excutes, qu'il y ait eu ou non une exception de dclenche et/ou d'intercepte.

Il est possible d'imbriquer plusieurs instructions try. Si un try imbriqu ne possde pas de clause catch, la clause catch du try du niveau suprieur sera utilise (et ainsi de suite).

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

Clause catch inconditionnelle

Lorsqu'une seule clause catch inconditionnelle est utilise, le bloc catch est utilise pour n'importe quelle exception qui est leve. Ainsi, dans le fragment de code qui suit, pour toute exception produite, le contrle de l'excution passera la clause catch.

try {
  throw "monException"; // gnre une exception
} catch (e) {
  // les instructions utilises pour grer les
  // exceptions
  logErreurs(e); // on transfre l'objet de l'exception  une mthode
  // gestionnaire
}

La clause catch dfinit un identifiant (dans l'exemple prcdent, c'est e) qui contient la valeur dfinie par l'instruction throw. Ce bloc catch est en quelque sorte unique en JavaScript car l'identifiant est cr lors de l'entre dans le bloc catch, la valeur est alors ajoute la porte courant et la dure de vie de l'identifiant est limite au bloc catch. Une fois que le bloc catch a t excut, l'identifiant n'est plus disponible.

Clauses catch conditionnelles

Il est aussi possible d'utiliser une ou plusieurs clauses catch conditionnelles afin de grer des exceptions spcifiques. Dans ce cas, selon l'exception produite, la clause catch approprie sera utilise. Dans l'exemple qui suit, le code contenu dans le bloc try peut produire trois exceptions : TypeError, RangeError, et EvalError. Lorsqu'une exception se produit, le contrle de l'excution est pass la clause catch correspondante. SI l'exception qui est dclenche ne correspond aucune des conditions, le contrle passera la clause catch non-conditionnelle si elle est trouve..

Si on utilise une clause catch inconditionnelle avec une ou plusieurs clauses catch conditionnelles, la clause inconditionnelle doit tre spcifie en dernire. Si ce n'est pas le cas, la clause catch inconditionnelle interceptera tous les types d'exceptions avant les autres clauses.

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

Dans le fragment de code qui suit, on aura le mme fonctionnement mais en utilisant uniquement des fonctionnalits 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 grer TypeError
  } else if (e instanceof RangeError) {
    // les instructions pour grer RangeError
  } else if (e instanceof EvalError) {
    // les instructions pour grer EvalError
  } else {
    // les instructions pour grer les autres exceptions
  }
}

L'identifiant de l'exception

Lorsqu'une exception est leve dans le bloc try, exception_var (par exemple le e dans catch (e) ) contient la valeur dfinie par l'instruction throw. Cet identifiant peut tre utilis pour accder aux proprits de l'objet et ainsi obtenir des informations sur l'exception qui a eu lieu. Cet identifiant est local la clause catch, il est cr lorsqu'on rentre dans la clause catch et n'est plus disponible une fois que la clause a fini son excution.

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

La clause finally

La clause finally contient les instructions excuter aprs que les instructions du bloc try et ventuellement celles de la clause catch aient t excutes mais avant que les instructions suivant l'instruction try soient excutes. La clause finally est excute dans tous les cas (si on a eu une exception ou non). Si une exception est leve et qu'il n'y a pas de clause catch, les instructions de la clause finally sont tout de mme excutes.

Cela peut paratre trange qu'un bloc de code qui s'excute mme lorsqu'il y a une exception Il faut comprendre que le code qui suit le bloc try...catch ne sera pas excut. Aussi, le bloc finally permet de contenir toutes les instructions de clture/nettoyage ncessaire. On vite donc de dupliquer ce code qui doit toujours tre utilis.

La clause finally peut tre utilise afin d'excuter les actions ncessaires pour que le script choue correctement en cas d'erreur. On peut par exemple tirer parti de finally pour fermer un flux, librer une ressource, etc. Dans l'exemple suivant, excut ct serveur, le script accde un fichier. Si une exception se produit lorsque le fichier est ouvert, la clause finally permet de fermer le fichier avant que le script choue. Le code contenu dans le bloc finally sera excut mme si on a une instruction return dans la section try ou dans la section catch.

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

Exemples

Blocs try imbriqus

Tout d'abord, on utilise ce fragment de code, qui produit le rsultat 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 dj intercept l'exception avec une clause catch 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 intercepte qu'une seule fois par le bloc catch le plus proche moins qu'elle ne soit retransmise nouveau. Bien entendu, toute exception qui aura t leve par le bloc interne (il se peut que les instructions d'une clause catch provoquent une erreur) sera intercepte par le bloc externe.

Valeur de retour et bloc finally

Lorsque le bloc finally renvoie une valeur, c'est cette valeur qui devient la valeur de retour pour l'ensemble du bloc try-catch-finally et ce, peu importe, s'il y a des instructions return dans les blocs try et catch. Cela inclue galement les exceptions leves dans le bloc catch :

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'instruction return est utilise dans la clause finally du bloc interne. Cela aurait galement t le cas avec n'importe quelle valeur renvoye par le bloc catch.

Spcifications

Compatibilit des navigateurs

Voir aussi

• Error
• throw