try...catch

Exemple interactif

try {
  nonExistentFunction();
} catch (error) {
  console.error(error);
  // Rsultat attendu : ReferenceError: nonExistentFunction is not defined
  // (Note : le rsultat exact peut dpendre du navigateur)
}

Syntaxe

try {
  tryStatements
} catch (exceptionVar) {
  catchStatements
} finally {
  finallyStatements
}

tryStatements

L'instruction excuter.

catchStatements

L'instruction excuter si une exception est leve dans la clause try.

exceptionVar Facultatif

Un identifiant ou un modle optionnel pour contenir l'exception capture pour la clause catch associ. Si la clause catch n'utilise pas la valeur de l'exception, vous pouvez omettre exceptionVar et ses parenthses environnantes.

finallyStatements

Les instructions qui sont excutes avant que le flux de contrle ne quitte la construction try...catch...finally. Ces instructions s'excutent indpendamment du fait qu'une exception ait t leve ou intercepte.

Description

L'instruction try commence toujours par une clause try. Ensuite, une clause catch ou une clause finally doit tre prsente. Il est galement possible d'avoir la fois une clause catch et une clause finally. Cela nous donne trois formes pour l'instruction try :

• try...catch
• try...finally
• try...catch...finally

Contrairement d'autres constructions telles que if ou for, les clauses try, catch et finally doivent tre des blocs, et non des instructions uniques.

try faireQuelqueChose(); // SyntaxError
catch (e) console.log(e);

Une clause catch contient des instructions qui dfinissent ce qu'il faut faire si une exception est leve dans la clause try. Si une instruction de la clause try (ou d'une fonction appele depuis la clause try) lve une exception, le contrle est immdiatement transfr la clause catch. Si aucune exception n'est leve dans la clause try, la clause catch est ignore.

La clause finally s'excute toujours avant que le flux de contrle ne quitte la construction try...catch...finally. Elle s'excute toujours, que une exception ait t leve ou intercepte.

Vous pouvez imbriquer une ou plusieurs instructions try. Si une instruction try interne n'a pas de clause catch, la clause catch de l'instruction try englobante est utilis la place.

Vous pouvez galement utiliser l'instruction try pour grer les exceptions JavaScript. Consultez le Guide JavaScript pour plus d'informations sur les exceptions JavaScript.

Lier la clause catch

Lorsqu'une exception est leve dans la clause try, exceptionVar (c'est--dire le e dans catch (e)) contient la valeur de l'exception. Vous pouvez utiliser cette liaison pour obtenir des informations sur l'exception qui a t leve. Cette liaison n'est disponible que dans la porte de la clause catch.

Il n'est pas ncessaire que ce soit un seul identifiant. Vous pouvez utiliser un modle de dstructuration pour affecter plusieurs identifiants la fois.

try {
  throw new TypeError("oups");
} catch ({ name, message }) {
  console.log(name); // "TypeError"
  console.log(message); // "oups"
}

Les liaisons cres par la clause catch vivent dans la mme porte que la clause catch, donc toutes les variables dclares dans la clause catch ne peuvent pas avoir le mme nom que les liaisons cres par la clause catch. (Il y a une exception cette rgle, mais c'est une syntaxe obsolte.)

try {
  throw new TypeError("oups");
} catch ({ name, message }) {
  var name; // SyntaxError: Identifier 'name' has already been declared
  let message; // SyntaxError: Identifier 'message' has already been declared
}

La liaison de l'exception est modifiable. Par exemple, vous pouvez vouloir normaliser la valeur de l'exception pour vous assurer qu'il s'agit d'un objet Error.

try {
  throw "Oups ; ce n'est pas un objet Error";
} catch (e) {
  if (!(e instanceof Error)) {
    e = new Error(e);
  }
  console.error(e.message);
}

Si vous n'avez pas besoin de la valeur de l'exception, vous pouvez l'omettre ainsi que les parenthses englobantes.

function estDuJSONValide(texte) {
  try {
    JSON.parse(texte);
    return true;
  } catch {
    return false;
  }
}

La clause finally

La clause finally contient des instructions excuter aprs l'excution des clauses try et catch, mais avant les instructions suivant la clause try...catch...finally. Le flux de contrle entre toujours dans la clause finally, qui peut se drouler de l'une des manires suivantes :

• Immdiatement aprs que le flux de contrle quitte la clause try dans une construction try...finally (soit aprs la dernire instruction ou une instruction throw, return, break, ou continue) ;
• Immdiatement aprs que le flux de contrle quitte la clause catch dans une construction try...catch...finally ;
• Immdiatement aprs que le flux de contrle quitte la clause try dans une construction try...catch...finally, sauf s'il quitte avec une instruction throw (auquel cas le flux de contrle entre dans la clause catch en premier).

Si la clause finally est excute aprs une instruction de contrle de flux (return, throw, break, continue) dans la clause try ou catch, l'effet de cette instruction est diffr jusqu'aprs la dernire instruction excute dans la clause finally. Par exemple, si une exception est leve depuis la clause try, mme lorsqu'il n'y a pas de clause catch pour grer l'exception, la clause finally s'excute toujours, et l'exception est leve immdiatement aprs l'excution de la clause finally.

Cependant, il existe une exception cette rgle : si la dernire instruction excute dans la clause finally est elle-mme une instruction de contrle de flux, cette instruction remplace l'effet de la prcdente (pas de diffr) ; voir retourner depuis une clause finally pour des exemples. Il est gnralement dconseill d'utiliser des instructions de contrle de flux (return, throw, break, continue) dans la clause finally, car elles peuvent remplacer l'effet des instructions de contrle de flux excutes prcdemment, ce qui est rarement souhait. La plupart du temps, la clause finally doit tre rserve au code de nettoyage qui ne modifie pas la logique principale.

Exemples

Clause catch inconditionnelle

Lorsqu'une clause catch est utilise, la clause catch est excute lorsqu'une exception est leve depuis la clause try. Par exemple, lorsque l'exception se produit dans le code suivant, le contrle est transfr la clause catch.

try {
  throw new Error("Mon exception"); // gnre une exception
} catch (e) {
  // les instructions pour grer toutes les exceptions
  journaliserMesErreurs(e); // passe l'objet exception au gestionnaire d'erreurs
}

La clause catch dfinit un identifiant (e dans l'exemple ci-dessus) qui contient la valeur de l'exception ; cette valeur n'est disponible que dans la porte de la clause catch.

Clauses catch conditionnelles

Vous pouvez crer des  clauses catch conditionnelles  en combinant des clauses try...catch avec des structures if...else if...else, comme ceci :

try {
  maRoutine(); // peut lever trois types d'exceptions
} catch (e) {
  if (e instanceof TypeError) {
    // les instructions pour grer les exceptions de type TypeError
  } else if (e instanceof RangeError) {
    // les instructions pour grer les exceptions de type RangeError
  } else if (e instanceof EvalError) {
    // les instructions pour grer les exceptions de type EvalError
  } else {
    // les instructions pour grer toutes les autres exceptions non dfinies
    journaliserMesErreurs(e); // passe l'objet exception au gestionnaire d'erreurs
  }
}

Un cas d'utilisation courant pour cela est de ne capturer (et de faire taire) qu'un petit sous-ensemble d'erreurs attendues, puis de relancer l'erreur dans les autres cas :

try {
  maRoutine();
} catch (e) {
  if (e instanceof RangeError) {
    // les instructions pour grer cette erreur attendue trs courante
  } else {
    throw e; // relance l'erreur inchange
  }
}

Cela peut imiter la syntaxe d'autres langages, comme Java :

try {
  maRoutine();
} catch (RangeError e) {
  // les instructions pour grer cette erreur attendue trs courante
}
// Les autres erreurs sont implicitement relances

Clauses try imbriques

Tout d'abord, voyons ce qui se passe avec ceci :

try {
  try {
    throw new Error("oups");
  } finally {
    console.log("final");
  }
} catch (ex) {
  console.error("externe", ex.message);
}

// Journaux :
// "final"
// "externe" "oups"

Maintenant, si nous avons dj intercept l'exception dans la clause try interne en ajoutant une clause catch :

try {
  try {
    throw new Error("oups");
  } catch (ex) {
    console.error("interne", ex.message);
  } finally {
    console.log("final");
  }
} catch (ex) {
  console.error("externe", ex.message);
}

// Journaux :
// "interne" "oups"
// "final"

Et maintenant, relanons l'erreur.

try {
  try {
    throw new Error("oups");
  } catch (ex) {
    console.error("interne", ex.message);
    throw ex;
  } finally {
    console.log("final");
  }
} catch (ex) {
  console.error("externe", ex.message);
}

// Journaux :
// "interne" "oups"
// "final"
// "externe" "oups"

Une exception donne n'est intercepte qu'une seule fois par le bloc catch le plus proche, moins qu'elle ne soit relance. Bien entendu, toute nouvelle exception leve dans le bloc  interne  (car le code du bloc catch peut effectuer une opration qui en lance une) est intercepte par le bloc  externe .

Librer des ressources avec finally

L'exemple suivant illustre un cas d'utilisation de la clause finally. Le code ouvre un fichier, puis excute des instructions qui utilisent ce fichier ; la clause finally garantit que le fichier est toujours ferm aprs son utilisation, mme si une exception a t leve.

ouvrirMonFichier();
try {
  // mobilise une ressource
  ecrireMonFichier(laDonnee);
} finally {
  fermerMonFichier(); // toujours fermer la ressource
  // toute exception non intercepte est diffre ici
}

De la mme manire, l'effet de toute instruction return dans la clause try est diffr la fin de la clause finally, bien que l'expression de la valeur de retour soit value avant d'entrer dans la clause finally.

function ecritureSecuriseeDeMonFichier() {
  ouvrirMonFichier();
  try {
    return ecrireMonFichier(laDonnee); // l'appel de fonction est valu
  } finally {
    fermerMonFichier(); // toujours fermer la ressource
    // le retour est diffr ici
  }
}

Retourner depuis une clause finally

L'exemple suivant illustre le comportement des instructions de contrle de flux dans la clause finally. Lorsque le flux de contrle sort de la clause try par la premire instruction return, l'expression de la valeur de retour (order.sort()) est value avant d'entrer dans la clause finally, et la fonction est prvue pour retourner cette valeur aprs l'excution de la clause finally. Cependant, l'instruction return dans la clause finally remplace l'effet de l'instruction return prcdente, y compris sa valeur de retour.

function faitLe() {
  const ordre = ["z"];
  try {
    ordre.push("essai");
    return ordre.sort(); // "z" est maintenant aprs "essai"
  } finally {
    ordre.push("final");
    return ordre;
  }
}
faitLe();
// retourne ["essai", "z", "final"], pas ["final", "essai", "z"] ou ["essai", "z"]

La mme logique s'applique aux autres instructions de contrle de flux. Ici, la fonction est d'abord prvue pour lever la valeur "attrap", mais retourne la place la valeur "final".

function faitLe() {
  try {
    throw "essai"; // fait entrer le flux de contrle dans la clause `catch`
  } catch {
    throw "attrap"; // fait entrer le flux de contrle dans la clause `finally`
  } finally {
    return "final"; // retourne "final" au lieu de lever "attrap"
  }
}
faitLe(); // retourne "final"

Encore une fois, les instructions de contrle de flux sont dconseilles dans la clause finally, car cet effet est probablement non souhait.

Spcifications

Compatibilit des navigateurs

Voir aussi

• L'objet Error
• L'instruction throw