Error

Les erreurs d'exécution ont pour résultat la création et le déclenchement d'objets Error.

En plus du constructeur Error générique, il existe d'autres constructeurs d'erreur natifs 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 se produisant en relation avec la fonction globale eval().

RangeError

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

ReferenceError

Crée une instance représentant une erreur se produisant 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 se produisant quand une variable ou un paramètre n'est pas d'un type valide.

URIError

Crée une instance représentant une erreur se produisant quand des paramètres invalides sont passés à encodeURI() ou à decodeURI().

AggregateError

Crée une instance représentant différentes erreurs agrégées en une seule lorsque plusieurs erreurs sont rapportées par une opération, par exemple avec Promise.any().

InternalError Non standard

Crée une instance représentant une erreur se produisant quand une erreur interne dans le moteur JavaScript est déclenchée. Par exemple, « too much recursion ».

Error()

Crée un nouvel objet Error.

Error.captureStackTrace()

Une fonction non-standard implémentée par le moteur V8 qui crée la propriété stack d'une instance de Error.

Error.prototype.message

Le message de l'erreur.

Error.prototype.name

Le nom de l'erreur.

Error.prototype.description Non standard

Une propriété non-standard, implémentée par Microsoft, qui décrit l'erreur. Analogue à message.

Error.prototype.number Non standard

Une propriété non-standard, implémentée par Microsoft, qui fournit un nombre pour chaque erreur.

Error.prototype.fileName Non standard

Une propriété non-standard, implémentée par Mozilla, qui indique le chemin du fichier à l'origine de l'erreur.

Error.prototype.lineNumber Non standard

Une propriété non-standard, implémentée par Mozilla, qui indique le numéro de la ligne du fichier à l'origine de l'erreur.

Error.prototype.columnNumber Non standard

Une propriété non-standard, implémentée par Mozilla, qui indique le numéro de la colonne de la ligne du fichier à l'origine de l'erreur.

Error.prototype.stack Non standard

Une propriété non-standard, implémentée par Mozilla, pour fournir une trace de la pile d'appels.

Error.prototype.toString()

Renvoie une chaîne de caractères qui représente l'objet courant. Surcharge la méthode Object.prototype.toString().

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 :

try {
  throw new Error("Oups !");
} catch (e) {
  console.log(e.name + " : " + e.message);
}

Il est possible de ne gérer que certains types d'erreur particuliers en testant le type de l'erreur via la propriété constructor ou grâce au 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-gérée
    throw e;
  }
}

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 peut être passée au constructeur Error avec le paramètre option (qui correspond à la propriété cause), cela permettra que l'erreur d'origine et la pile d'appels seront 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()):

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;
  }
}

Il est aussi possible d'utiliser la propriété cause des types d'erreur personnalisés, si celle-ci est fournie via le paramètre options du constructeur de la sous-classe lors de l'appel à super() :

class MonErreur extends Error {
  constructor(/* des arguments */) {
    // Il faut passer les paramètres `message` et `options`
    // pour que la propriété "cause" soit initialisée.
    super(message, options);
  }
}

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 cette question (en anglais) sur StackOverflow pour une discussion détaillée.

En utilisant les classes ES2015

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
}

En utilisant des objets ES5

function ErreurSpecifique(toto, message, fileName, lineNumber) {
  var instance = new Error(message, fileName, lineNumber);
  instance.name = "ErreurSpecifique";
  instance.toto = toto;
  Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
  if (Error.captureStackTrace) {
    Error.captureStackTrace(instance, ErreurSpecifique);
  }
  return instance;
}

ErreurSpecifique.prototype = Object.create(Error.prototype, {
  constructor: {
    value: Error,
    enumerable: false,
    writable: true,
    configurable: true,
  },
});

if (Object.setPrototypeOf) {
  Object.setPrototypeOf(ErreurSpecifique, Error);
} else {
  ErreurSpecifique.__proto__ = Error;
}

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

• Une prothèse d'émulation pour Error qui inclut la prise en charge de cause, disponible avec core-js
• throw
• try…catch