Error

Description

Les erreurs d'excution entranent la cration et la leve de nouveaux objets Error.

Error est un objet srialisable, il peut donc tre clon avec structuredClone() ou copi entre Workers en utilisant postMessage().

Types d'erreur

Outre le constructeur gnrique Error, il existe d'autres constructeurs d'erreur principaux en JavaScript. Pour les exceptions ct client, voir Contrle du flux d'instructions et gestion des erreurs.

EvalError

Cre une instance reprsentant une erreur qui se produit concernant la fonction globale eval().

RangeError

Cre une instance reprsentant une erreur qui se produit lorsqu'une variable ou un paramtre numrique est en dehors de sa plage de validit.

ReferenceError

Cre une instance reprsentant une erreur qui se produit lors du drfrencement d'une rfrence invalide.

SyntaxError

Cre une instance reprsentant une erreur de syntaxe.

TypeError

Cre une instance reprsentant une erreur qui se produit lorsqu'une variable ou un paramtre n'est pas d'un type valide.

URIError

Cre une instance reprsentant une erreur qui se produit lorsque encodeURI() ou decodeURI() reoivent des paramtres invalides.

AggregateError

Cre une instance reprsentant plusieurs erreurs regroupes dans une seule erreur lorsque plusieurs erreurs doivent tre signales par une opration, par exemple par Promise.any().

InternalError

Cre une instance reprsentant une erreur qui se produit lorsqu'une erreur interne du moteur JavaScript est leve. Par exemple  too much recursion .

Constructeur

Error()

Cre un nouvel objet Error.

Proprits statiques

Error.stackTraceLimit

Une proprit numrique non standard qui limite le nombre de trames de pile inclure dans une trace de pile d'erreur.

Mthodes statiques

Error.captureStackTrace()

Une fonction non standard qui cre la proprit stack sur l'objet fourni.

Error.isError()

Retourne true si l'argument est une erreur, ou false sinon.

Error.prepareStackTrace() Facultatif

Une fonction non standard qui, si elle est fournie par le code de l'utilisateurice, est appele par le moteur JavaScript pour les exceptions leves, permettant l'utilisateurice de fournir un formatage personnalis pour les traces de pile. Voir la documentation de l'API V8 Stack Trace (angl.).

Proprits d'instance

Ces proprits sont dfinies sur Error.prototype et partages par toutes les instances de Error.

Error.prototype.constructor

La fonction constructeur qui a cr l'objet d'instance. Pour les instances de Error, la valeur initiale est le constructeur Error.

Error.prototype.name

Reprsente le nom du type d'erreur. Pour Error.prototype.name, la valeur initiale est "Error". Les sous-classes comme TypeError et SyntaxError fournissent leur propre proprit name.

Error.prototype.stack

Une proprit non standard pour une trace de pile.

Ces proprits sont des proprits propres chaque instance de Error.

cause

Cause de l'erreur indiquant la raison pour laquelle l'erreur courante est leve gnralement une autre erreur intercepte. Pour les objets Error crs par l'utilisateurice, il s'agit de la valeur fournie comme proprit cause du second argument du constructeur.

columnNumber

Proprit non standard de Mozilla pour le numro de colonne dans la ligne qui a gnr cette erreur.

fileName

Proprit non standard de Mozilla pour le chemin du fichier qui a gnr cette erreur.

lineNumber

Proprit non standard de Mozilla pour le numro de ligne dans le fichier qui a gnr cette erreur.

message

Message d'erreur. Pour les objets Error crs par l'utilisateurice, il s'agit de la chane de caractres fournie comme premier argument du constructeur.

Mthodes d'instance

Error.prototype.toString()

Retourne une chane de caractres reprsentant l'objet dfini. Redfinit la mthode Object.prototype.toString().

Exemples

Dclenchement d'une erreur gnrique

On cre habituellement un objet Error dans l'intention de le dclencher en utilisant le mot-cl throw. L'erreur peut ensuite tre intercepte et gre en utilisant la construction try...catch :

try {
  throw new Error("Oups !");
} catch (e) {
  console.error(`${e.name} : ${e.message}`);
}

Gestion d'une erreur spcifique

Vous pouvez choisir de grer uniquement certains types d'erreur en testant le type de l'erreur avec le mot-cl instanceof :

try {
  toto.truc();
} catch (e) {
  if (e instanceof EvalError) {
    console.error(`${e.name} : ${e.message}`);
  } else if (e instanceof RangeError) {
    console.error(`${e.name} : ${e.message}`);
  }
  // etc.
  else {
    // Si aucun cas ne correspond, on laisse l'erreur non gre
    throw e;
  }
}

Distinguer des erreurs semblables

Il arrive parfois que des erreurs semblables (type et message identiques) ncessitent des traitements diffrents.

Si vous ne matrisez pas l'origine des erreurs, vous pouvez les intercepter et renvoyer de nouveaux objets Error avec des messages plus spcifiques. L'erreur d'origine doit tre passe au nouveau Error dans le paramtre options du constructeur comme proprit cause. Cela garantit que l'erreur d'origine et la pile d'appels sont disponibles pour les blocs try/catch de plus haut niveau.

Dans l'exemple qui suit, on illustre ceci pour deux mthodes qui chouent avec des erreurs similaires (echecUneFacon() et echecAutreFacon()) :

function faireTruc() {
  try {
    echecUneFacon();
  } catch (err) {
    throw new Error("Echoue d'une certaine faon", { cause: err });
  }
  try {
    echecAutreFacon();
  } catch (err) {
    throw new Error("Echoue d'une autre faon", { cause: err });
  }
}

try {
  faireTruc();
} catch (err) {
  switch (err.message) {
    case "Echoue d'une certaine faon":
      gererUneFacon(err.cause);
      break;
    case "Echoue d'une autre faon":
      gererUneAutreFacon(err.cause);
      break;
  }
}

Les types d'erreur personnaliss peuvent galement utiliser la proprit cause, condition que le constructeur des sous-classes transmette le paramtre options lors de l'appel super(). Le constructeur de la classe de base Error() lit options.cause et dfinit la proprit cause sur la nouvelle instance d'erreur.

class MonErreur extends Error {
  constructor(message, options) {
    // Il faut passer l'argument `options` en second paramtre
    // pour que la proprit "cause" soit initialise.
    super(message, options);
  }
}

console.log(new MonErreur("test", { cause: new Error("cause") }).cause);
// Error: cause

Types d'erreur personnaliss

Il est possible de dfinir ses propres types d'erreur drivs de Error et d'utiliser alors throw new MonErreur() et instanceof MonErreur pour vrifier le type d'erreur lors du traitement. Cela permet d'avoir un code plus concis et cohrent pour le traitement des erreurs.

Voir  Quelle est une bonne faon d'tendre Error en JavaScript ?  (angl.) sur StackOverflow pour une discussion dtaille.

class ErreurSpecifique extends Error {
  constructor(toto = "truc", ...params) {
    // On passe les arguments restants (y compris ceux
    // de l'diteur tiers) au constructeur parent
    super(...params);

    // On garde la pile d'appels de l'erreur
    // Uniquement disponible pour V8
    if (Error.captureStackTrace) {
      Error.captureStackTrace(this, ErreurSpecifique);
    }

    this.name = "ErreurSpecifique";
    // Les informations de dbogage spcifiques
    this.toto = toto;
    this.date = new Date();
  }
}

try {
  throw new ErreurSpecifique("truc", "trucMessage");
} catch (e) {
  console.error(e.name); // ErreurSpecifique
  console.error(e.toto); // truc
  console.error(e.message); // trucMessage
  console.error(e.stack); // stacktrace
}

Spcifications

Compatibilit des navigateurs

Voir aussi

• Prothse d'mulation pour Error avec la prise en charge de cause (angl.)
• Prothse d'mulation es-shims de Error cause (angl.)
• L'instruction throw
• L'instruction try...catch
• L'API de trace de pile (angl.) dans la documentation V8