MDN may have intermittent access issues April 18 13:00 - April 19 01:00 UTC. See whistlepig.mozilla.org for all notifications.

mozilla
Vos résultats de recherche

    Error

    Résumé

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

    Syntaxe

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

    Paramètres

    message
    Description de l'erreur sous une forme compréhensible pour un humain
    fileName
    Paramètre optionnel, 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
    Paramètre optionnel, 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 l'article sur la gestion des exceptions.

    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 intervalle de valeurs.
    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 de paramètres invalides 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

    Toutes les instances d'Error et les instances des erreurs non-génériques héritent de Error.prototype. Comme pour tous les constructeurs, on pouvez utiliser le prototype du constructeur pour ajouter des propriétés ou méthodes à l'ensemble des instances créées avec ce constructeur.

    Propriétés

    Propriétés standard

    Error.prototype.constructor
    La fonction créeant une instance du prototype.
    Error.prototype.message
    Le message de l'erreur.
    Error.prototype.name
    Le nom de l'erreur.

    Extensions spécifiques à une implémentation

    Non standard
    Cette fonctionnalité n'est ni standard, ni en voie de standardisation. Ne l'utilisez pas pour des sites accessibles sur le Web : elle ne fonctionnera pas pour tout utilisateur. Il peut également y avoir d'importantes incompatibilités entre les implémentations et son comportement peut être modifié dans le futur.

    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é l'erreur dans le fichier.
    Error.prototype.columnNumber
    Numéro de la colonne qui a déclenché l'erreur dans le fichier.
    Error.prototype.stack
    Pile d'appels.

    Méthodes

    Error.prototype.toSource()
    Renvoie une chaine de caractères contenant le code source de l'objet Error ; cette vlaeur peut être utilisée pour créer un nouvel objet. Elle remplace la méthode Object.prototype.toSource().
    Error.prototype.toString()
    Renvoie une chaine de caractères représentant l'objet. Elle remplace la méthode Object.prototype.toString().

    Exemples

    Lever une erreur générique

    On utilisera le mot-clé throw pour lever une exception. L'erreur générée peut ensuite être « gérée » en utilisant l'instruction try...catch :

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

    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 {
        toto.truc();
    } catch (e) {
        if (e instanceof EvalError) {
            console.log(e.name + ": " + e.message);
        } else if (e instanceof RangeError) {
            console.log(e.name + ": " + e.message);
        }
        // ... etc
    }
    

    Types d'erreur personnalisés

    On peut avoir besoin de types d'erreur spécifiques, dérivés de Erreur pour pouvoir exécuter throw new MonErreur() et utiliser instanceof MonErreur afin de vérifier le type d'erreur lorsqu'on gère l'exception. La façon la plus courante pour créer un tel objet est présentée ci-dessous :

    Attention : le rapport d'une erreur MonErreur renverra des lineNumber et fileName incorrects (dans Firefox).

    Sur ce sujet, voir aussi la page « Quelle est la meilleure façon d'étendre l'objet Error en JavaScript ? » sur Stack Overflow (en anglais).

    // On crée un nouvel objet, héritage par prototype depuis le constructeur de type Error
    function MonErreur(message) {
        this.name = "MonErreur";
        this.message = message || "Message par défaut";
    }
    MonErreur.prototype = Object.create(Error.prototype);
    MonErreur.prototype.constructor = MonErreur;
    
    try {
        throw new MonErreur();
    } catch (e) {
        console.log(e.name);     // "MonErreur"
        console.log(e.message);  // "Message par défaut"
    }
    
    try {
        throw new MonErreur("message plus précis");
    } catch (e) {
        console.log(e.name);     // "MonErreur"
        console.log(e.message);  // "message plus précis"
    }
    

    Spécifications

    Spécification Statut Commentaires
    Première édition d'ECMAScript. Standard Définition initiale. Implémentée avec JavaScript 1.1.
    ECMAScript 5.1 (ECMA-262)
    La définition de 'Error' dans cette spécification.
    Standard  
    ECMAScript 6 (ECMA-262)
    La définition de 'Error' dans cette spécification.
    En cours de validation comme recommandation  

    Compatibilité des navigateurs

    Fonctionnalité Chrome Firefox (Gecko) Internet Explorer Opera Safari
    Support simple (Oui) (Oui) (Oui) (Oui) (Oui)
    Fonctionnalité Android Chrome pour Android Firefox Mobile (Gecko) IE Mobile Opera Mobile Safari Mobile
    Support simple (Oui) (Oui) (Oui) (Oui) (Oui) (Oui)

    Voir aussi

    Étiquettes et contributeurs liés au document

    Contributors to this page: tregagnon, fscholz, SphinxKnight, Goofy, teoli, rd6137
    Dernière mise à jour par : SphinxKnight,