mozilla
Vos résultats de recherche

    instanceof

    L'opérateur instanceof permet de tester si un objet possède, dans sa chaîne de prototype, la propriété prototype d'un certain constructeur.

    Syntaxe

    objet instanceof constructeur

    Paramètres

    objet
    L'objet qu'on souhaite analyser.
    constructeur
    La fonction dont on souhaite vérifier la présence dans la chaîne de prototypes.

    Description

    L'opérateur instanceof teste la présence de constructeur.prototype dans la chaîne de prototypes d'objet.

    function C(){} // Définition du constructeur
    function D(){} // Définition d'un autre constructeur
    
    var o = new C();
    
    // true, car : Object.getPrototypeOf(o) === C.prototype
    o instanceof C; 
    
    // false, car D.prototype n'existe pas dans la chaîne prototype de o
    o instanceof D;
     
    o instanceof Object; // true, car:
    C.prototype instanceof Object // true
    
    C.prototype = {};
    var o2 = new C();
    
    o2 instanceof C; // true
    
    // false, car C.prototype n'existe plus dans la chaîne prototype de o
    o instanceof C; 
    
    D.prototype = new C(); // Utilisation de l'héritage
    var o3 = new D();
    o3 instanceof D; // true
    o3 instanceof C; // true
    

    À noter que si la valeur retournée par instanceof peut être differente suite à un changement de la propriété prototype du constructeur, ce n'est pas faisable en changeant le prototype d'un objet. En effet, changer le prototype d'un objet n'est pas possible suivant le standard ECMAScript. C'est néanmoins faisable en utilisant la pseudo-propriété __proto__ non-standard.

    instanceof dans d'autres contextes (frames ou fenêtres)

    Différents niveaux d'intégrations ont différents environnements. Cela signifie que les valeurs retournées sont différentes (objet globaux différents, constructeurs différents, etc.). Cela peut engendrer des résultats inattendus. Par exemple, [] instanceof window.frames[0].Array renverra false, car Array !== window.frames[0].Array et que les tableaux héritent de leur constructeur. Cela peut être contre-intuitif au début, mais lorsqu'il est nécessaire de travailler avec plusieurs frames ou fenêtres, et que des objets sont transférés via des fonctions, cela sera un obstacle valide et important. Par contre, il est tout à fait possible d'utiliser Array.isArray(myObj) pour vérifier de manière sécurisée qu'un tableau est effectivement un tableau.

    Note aux développeurs Mozilla :
    Dans un code utilisant XPCOM, instanceof à un comportement particulier : obj instanceof xpcomInterface (ex : Components.interfaces.nsIFile) appelle obj.QueryInterface(xpcomInterface) et retourne true si QueryInterface réussit. Un effet indésirable à cela est qu'il est possible d'utiliser les propriétés de xpcomInterface sur obj après un test réussi d'instanceof. Contrairement au JavaScript classique, obj instanceof xpcomInterface fonctionnera comme prévu même si obj appartient à un autre niveau d'organisation (fenêtre, frame, etc.).

    Exemples

    Démonstration que String et Date sont de type Object et cas aux limites des littéraux

    Le code suivant utilise instanceof pour démontrer que les objets String et Date sont aussi de type Object (ils dérivent d'Object).

    Cependant, les objets créés à partir de littéraux objets sont une exception : en effet, bien que leur prototype ne soit pas définit, instanceof Object renvoie true.

    var chaîneSimple = "Une chaîne simple";
    var maChaîne  = new String();
    var newChaîne = new String("Chaîne créée avec un constructeur");
    var maDate    = new Date();
    var monObjet  = {};
    
    chaîneSimple instanceof String; //false car le prototype vaut undefined
    maChaîne  instanceof String; // true
    newChaîne instanceof String; // true
    maChaîne  instanceof Object; // true
    
    monObjet instanceof Object;// true, bien que le protoype soit undefined
    ({}) instanceof Object;    // true, comme pour le cas précédent
    
    maChaîne instanceof Date;   // false
    
    maDate instanceof Date;     // true
    maDate instanceof Object;   // true
    maDate instanceof String;   // false
    

    Démonstration que mavoiture est de type Voiture et de type Object

    Le code suivant créé un objet de type Voiture et une instance de cet objet, mavoiture. L'opérateur instanceof montre que l'objet mavoiture est de type Voiture et de type Object.

    function Voiture(fabricant, modele, annee) {
      this.fabricant = fabricant;
      this.modele = modele;
      this.annee = annee;
    }
    var mavoiture = new Voiture("Citroën", "C3", 2006);
    var a = mavoiture instanceof Voiture; // retourne true
    var b = mavoiture instanceof Object;  // retourne true
    

    Spécifications

    Spécification Statut Commentaires
    Première édition d'ECMAScript. Standard Définition initiale. Implémentée par JavaScript 1.4
    ECMAScript 5.1 (ECMA-262)
    La définition de 'The instanceof operator' dans cette spécification.
    Standard  
    ECMAScript 6 (ECMA-262)
    La définition de 'Relational Operators' 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: Slagt, a5er, Automatik, teoli, SphinxKnight
    Dernière mise à jour par : SphinxKnight,
    Masquer la barre latérale