Error - JavaScript | MDN

Basculer la barre latérale

Thème

Automatique
Clair
Sombre

Français

Se souvenir de la langue En savoir plus

Error

Baseline Large disponibilité *

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.

* Certaines parties de cette fonctionnalité peuvent bénéficier de prise en charge variables.

Les objets Error sont levés lorsque des erreurs d'exécution se produisent. L'objet Error peut aussi être utilisé comme objet de base pour des exceptions définies par l'utilisateur·ice. Voir ci-dessous pour les types d'erreurs intégrés standards.

Dans cet article

Description

Les erreurs d'exécution entraînent la création et la levée de nouveaux objets Error.

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

Types d'erreur

Outre le constructeur générique Error, il existe d'autres constructeurs d'erreur principaux en JavaScript. Pour les exceptions côté client, voir Contrôle du flux d'instructions et gestion des erreurs.

EvalError

Crée une instance représentant une erreur qui se produit concernant la fonction globale eval().

RangeError

Crée une instance représentant une erreur qui se produit lorsqu'une variable ou un paramètre numérique est en dehors de sa plage de validité.

ReferenceError

Crée une instance représentant une erreur qui se produit lors du déréférencement d'une référence invalide.

SyntaxError

Crée une instance représentant une erreur de syntaxe.

TypeError

Crée une instance représentant une erreur qui se produit lorsqu'une variable ou un paramètre n'est pas d'un type valide.

URIError

Crée une instance représentant une erreur qui se produit lorsque encodeURI() ou decodeURI() reçoivent des paramètres invalides.

AggregateError

Crée une instance représentant plusieurs erreurs regroupées dans une seule erreur lorsque plusieurs erreurs doivent être signalées par une opération, par exemple par Promise.any().

InternalError

Crée une instance représentant une erreur qui se produit lorsqu'une erreur interne du moteur JavaScript est levée. Par exemple « too much recursion ».

Constructeur

Error()

Crée un nouvel objet Error.

Propriétés statiques

Error.stackTraceLimit

Une propriété numérique non standard qui limite le nombre de trames de pile à inclure dans une trace de pile d'erreur.

Méthodes statiques

Error.captureStackTrace()

Une fonction non standard qui crée la propriété 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'utilisateur·ice, est appelée par le moteur JavaScript pour les exceptions levées, permettant à l'utilisateur·ice de fournir un formatage personnalisé pour les traces de pile. Voir la documentation de l'API V8 Stack Trace (angl.).

Propriétés d'instance

Ces propriétés sont définies sur Error.prototype et partagées 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

Représente 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 propriété name.

Error.prototype.stack

Une propriété non standard pour une trace de pile.

Ces propriétés sont des propriétés propres à chaque instance de Error.

cause

Cause de l'erreur indiquant la raison pour laquelle l'erreur courante est levée — généralement une autre erreur interceptée. Pour les objets Error créés par l'utilisateur·ice, il s'agit de la valeur fournie comme propriété cause du second argument du constructeur.

columnNumber

Propriété non standard de Mozilla pour le numéro de colonne dans la ligne qui a généré cette erreur.

fileName

Propriété non standard de Mozilla pour le chemin du fichier qui a généré cette erreur.

lineNumber

Propriété non standard de Mozilla pour le numéro de ligne dans le fichier qui a généré cette erreur.

message

Message d'erreur. Pour les objets Error créés par l'utilisateur·ice, il s'agit de la chaîne de caractères fournie comme premier argument du constructeur.

Méthodes d'instance

Error.prototype.toString()

Retourne une chaîne de caractères représentant l'objet défini. Redéfinit la méthode Object.prototype.toString().

Exemples

Déclenchement d'une erreur générique

On crée habituellement un objet Error dans l'intention de le déclencher en utilisant le mot-clé throw. L'erreur peut ensuite être interceptée et gérée en utilisant la construction try...catch :

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

Gestion d'une erreur spécifique

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

js
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 gérée
    throw e;
  }
}

Distinguer des erreurs semblables

Il arrive parfois que des erreurs semblables (type et message identiques) nécessitent des traitements différents.

Si vous ne maîtrisez pas l'origine des erreurs, vous pouvez les intercepter et renvoyer de nouveaux objets Error avec des messages plus spécifiques. L'erreur d'origine doit être passée au nouveau Error dans le paramètre options du constructeur comme propriété 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 méthodes qui échoueraient avec des erreurs similaires (echecUneFacon() et echecAutreFacon()) :

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

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

Note : Si vous créez une bibliothèque, il est préférable d'utiliser la cause de l'erreur pour différencier les différentes erreurs émises — plutôt que de demander à vos utilisateur·ice·s d'analyser le message d'erreur. Voir la page sur la cause d'erreur pour un exemple.

Les types d'erreur personnalisés peuvent également utiliser la propriété cause, à condition que le constructeur des sous-classes transmette le paramètre options lors de l'appel à super(). Le constructeur de la classe de base Error() lira options.cause et définira la propriété cause sur la nouvelle instance d'erreur.

js
class MonErreur extends Error {
  constructor(message, options) {
    // Il faut passer l'argument `options` en second paramètre
    // pour que la propriété "cause" soit initialisée.
    super(message, options);
  }
}

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

Types d'erreur personnalisés

Il est possible de définir ses propres types d'erreur dérivés de Error et d'utiliser alors throw new MonErreur() et instanceof MonErreur pour vérifier le type d'erreur lors du traitement. Cela permet d'avoir un code plus concis et cohérent pour le traitement des erreurs.

Voir « Quelle est une bonne façon d'étendre Error en JavaScript ? » (angl.) sur StackOverflow pour une discussion détaillée.

Attention : Le sous-classage natif ne peut pas être transpilé de manière fiable vers du code pré-ES6, car il n'existe aucun moyen de construire la super-classe avec un new.target particulier sans Reflect.construct(). Vous avez besoin d'une configuration supplémentaire (angl.) ou d'appeler manuellement Object.setPrototypeOf(this, CustomError.prototype) à la fin du constructeur ; sinon, l'instance construite ne sera pas une instance de CustomError. Voir la FAQ TypeScript (angl.) pour plus d'informations.

Note : Certains navigateurs incluent le constructeur CustomError dans la pile d'appel lorsque les classes ES2015 sont utilisées.

js
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 débogage spécifiques
    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
}

Prothèse d'émulation pour Error avec la prise en charge de cause (angl.)
Prothèse 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

Aider à améliorer MDN

Cette page vous a-t-elle été utile ?

Oui Non

Apprendre à contribuer

Cette page a été modifiée le 21 févr. 2026 par les contributeur·ice·s du MDN.

Voir cette page sur GitHub • Signaler un problème avec ce contenu

Objets natifs standards
Error
Constructeur
1. Error()
Méthodes statiques
1. captureStackTrace()
2. isError()
Propriétés statiques
1. stackTraceLimit
Méthodes d'instance
1. toString()
Propriétés d'instance
1. cause
2. columnNumber
3. fileName
4. lineNumber
5. message
6. name
7. stack
Héritage
Object/Function
Méthodes statiques
1. apply()
2. bind()
3. call()
4. toString()
5. [Symbol.hasInstance]()
Propriétés statiques
1. displayName
2. length
3. name
4. prototype
5. arguments
6. caller
Méthodes d'instance
1. Object.prototype.__defineGetter__()
2. Object.prototype.__defineSetter__()
3. Object.prototype.__lookupGetter__()
4. Object.prototype.__lookupSetter__()
5. Object.prototype.hasOwnProperty()
6. Object.prototype.isPrototypeOf()
7. Object.prototype.propertyIsEnumerable()
8. Object.prototype.toLocaleString()
9. Object.prototype.toString()
10. Object.prototype.valueOf()
Propriétés d'instance
1. Object.prototype.__proto__
2. Object.prototype.constructor
Pages similaires
AggregateError
EvalError
InternalError
RangeError
ReferenceError
SyntaxError
TypeError
URIError