Error

Résumé

Le constructeur Error crée un objet d'erreur. Des instances d'objets Error sont levées lorsqu'une erreur d'exécution survient. L'objet Error peut aussi être utilisé comme base pour des erreurs définies par l'utilisateur. Voir ci-dessous pour les différents types d'erreur en natifs.

Syntaxe

new Error([message[, fileName[,lineNumber]]])

Paramètres

message

Description de l'erreur compréhensible pour un humain

fileName

Nom du fichier dont le code a levé l'exception. Par défaut, il s'agira du fichier contenant l'invocation du constructeur Error().

lineNumber

Numéro de ligne dans le code à l'origine de l'exception. Par défaut, il s'agira de la ligne qui contient l'invocation du constructeur Error().

Description

Une erreur survenant pendant l'exécution du programme entraîne la création et la levée d'un objet Error.

Cette page ne se concentre que sur l'objet Error en tant que tel, ainsi que la manière de l'utiliser comme constructeur. La liste des propriétés et méthodes disponibles par héritage dans les instances de l'objet Error peut être trouvée sur la page Error.prototype.

Types d'erreur

Il existe, en plus du constructeur générique Error, six autres constructeurs d'erreurs natifs en JavaScript. Les exceptions causées par le client sont détaillées dans la page Exception Handling Statements.

EvalError

Crée une instance d'une erreur survenue suite à l'utilisation de la fonction globale eval().

RangeError

Crée une instance d'erreur survenue suite à l'utilisation d'une variable numérique ou d'un paramètre hors de son domaine de valeur.

ReferenceError

Crée une instance d'erreur survenue suite au dé-référencement d'une référence invalide.

SyntaxError

Crée une instance d'erreur survenue suite à une erreur de syntaxe lors de la lecture du code par la fonction eval().

TypeError

Crée une instance d'erreur survenue lorsqu'une variable ou un paramètre n'est pas d'un type valide

URIError

Crée une instance d'erreur survenue lors d'un passage invalide de paramètres aux fonctions encodeURI() ou decodeURl().

Propriétés

Error.prototype

Permet l'ajout de propriétés aux instances de l'objet Error.

Méthodes

L'objet global Error ne contient pas de méthodes en propre, mais il hérite de certaines méthodes par la chaine de prototype.

Instances de Error

Propriétés

Propriétés standard

Error.prototype.constructor

La fonction créeant une instance du prototype.

Error.prototype.message

Message de l'erreur.

Error.prototype.name

Nom de l'erreur.

Extensions spécifiques à une implémentation

Microsoft

Error.prototype.description

Description de l'erreur. Similaire à message.

Error.prototype.number

Numéro de l'erreur.

Mozilla

Error.prototype.fileName

Chemin vers le fichier qui a déclenché l'erreur.

Error.prototype.lineNumber

Numéro de la ligne qui a déclenchée l'erreur dans le fichier.

Error.prototype.columnNumber

Numéro de la colonne qui a déclenchée l'erreur dans le fichier.

Error.prototype.stack

Stack trace.

Méthodes

Error.prototype.toSource()

Renvoie une chaine de caractères contenant le code source de l'objet Error ; vous pouvez utiliser cette valeur pour créer un nouveau objet. Remplace la méthode Object.prototype.toSource().

Error.prototype.toString()

Renvoie une chaine de caractères représentant l'objet. Remplace la méthode Object.prototype.toString().

Exemples

Exemple : Soulever une erreur globale

Vous utiliserez le plus souvent le mot-clé throw pour soulever une erreur que vous avez créée. Vous pouvez ensuite gérer cette erreur dans une construction try...catch:

try {
    throw new Error("Whoops!");
} catch (e) {
    alert(e.name + ": " + e.message);
}

Exemple : Gérer une erreur spécifique

Vous pouvez choisir de ne gérer qu'un type bien spécifique d'erreur en vérifiant son type via la propriété constructor de l'erreur, ou, si vous utilisez plutôt des interpréteurs Javascript modernes, le mot-clé instanceof.

try {
    foo.bar();
} catch (e) {
    if (e instanceof EvalError) {
        alert(e.name + ": " + e.message);
    } else if (e instanceof RangeError) {
        alert(e.name + ": " + e.message);
    }
    // ... etc
}

Types d'erreur personnalisés

Vous pouvez souhaiter définir vos propres types d'erreur dérivés de Erreur pour pouvoir throw new MyError() et utiliser instanceof MyError pour vérifier le type d'erreur dans votre gestionnaire d'erreur. La façon la plus courante est présentée ci-dessous :

// Crée un nouvel objet, héritage par prototype depuis le constructeur de type Error
function MyError(message) {
    this.name = "MyError";
    this.message = message || "Default Message";
}
MyError.prototype = new Error();
MyError.prototype.constructor = MyError;

try {
    throw new MyError();
} catch (e) {
    console.log(e.name);     // "MyError"
    console.log(e.message);  // "Default Message"
}

try {
    throw new MyError("custom message");
} catch (e) {
    console.log(e.name);     // "MyError"
    console.log(e.message);  // "custom message"
}

Spécifications

Compatibilité des navigateurs

Voir également

• Error.prototype
• throw
• try...catch